synapse 2.221.0__py311-none-any.whl → 2.223.0__py311-none-any.whl

synapse/lib/stormlib/task.py

@@ -0,0 +1,115 @@
+import asyncio
+import logging
+
+import synapse.exc as s_exc
+import synapse.lib.stormtypes as s_stormtypes
+
+logger = logging.getLogger(__name__)
+
+stormcmds = [
+    {
+        'name': 'task.list',
+        'descr': 'List running tasks on the Cortex and any mirrors.',
+        'cmdargs': (
+            ('--verbose', {'default': False, 'action': 'store_true', 'help': 'Enable verbose output.'}),
+        ),
+        'storm': '''
+            $tcnt = (0)
+            for $task in $lib.task.list() {
+                $lib.print(`task iden: {$task.iden}`)
+                $lib.print(`    name: {$task.name}`)
+                $lib.print(`    user: {$task.username}`)
+                $lib.print(`    service: {$task.service}`)
+                $lib.print(`    start time: {$lib.time.format($task.tick, '%Y-%m-%d %H:%M:%S')}`)
+                $lib.print('    metadata:')
+                if $cmdopts.verbose {
+                    $lib.pprint($task.info, prefix='    ')
+                } else {
+                    $lib.pprint($task.info, prefix='    ', clamp=120)
+                }
+                $tcnt = ($tcnt + 1)
+            }
+
+            if ($tcnt = 1) {
+                $lib.print('1 task found.')
+            } else {
+                $lib.print(`{$tcnt} tasks found.`)
+            }
+        ''',
+    },
+    {
+        'name': 'task.kill',
+        'descr': 'Kill a running task on the Cortex or a mirror.',
+        'cmdargs': (
+            ('iden', {'help': 'Any prefix that matches exactly one valid task iden is accepted.'}),
+        ),
+        'storm': '''
+            $kild = $lib.task.kill($cmdopts.iden)
+            $lib.print("kill status: {kild}", kild=$kild)
+        ''',
+    },
+]
+
+@s_stormtypes.registry.registerLib
+class LibTask(s_stormtypes.Lib):
+    '''
+    A Storm Library for interacting with tasks on a Cortex and its mirrors.
+    '''
+    _storm_locals = (
+        {'name': 'list', 'desc': 'List tasks the current user can access on the Cortex and its mirrors.',
+         'type': {'type': 'function', '_funcname': '_methTaskList', 'args': (),
+                  'returns': {'name': 'yields', 'type': 'dict', 'desc': 'Task definitions.'}}},
+        {'name': 'kill', 'desc': 'Stop a running task on the Cortex or a mirror.',
+         'type': {'type': 'function', '_funcname': '_methTaskKill', 'args': (
+                      {'name': 'prefix', 'type': 'str',
+                       'desc': 'The prefix of the task to stop. '
+                               'Tasks will only be stopped if there is a single prefix match.'},),
+                  'returns': {'type': 'boolean', 'desc': 'True if the task was cancelled, False otherwise.'}}},
+    )
+    _storm_lib_path = ('task',)
+    _storm_lib_perms = (
+        {'perm': ('task', 'get'), 'gate': 'cortex',
+         'desc': 'Permits a user to view tasks owned by other users.'},
+        {'perm': ('task', 'del'), 'gate': 'cortex',
+         'desc': 'Permits a user to kill tasks owned by other users.'},
+    )
+
+    def getObjLocals(self):
+        return {
+            'list': self._methTaskList,
+            'kill': self._methTaskKill,
+        }
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methTaskList(self):
+        useriden = self.runt.user.iden
+        isallowed = self.runt.allowed(('task', 'get'))
+
+        async for task in self.runt.snap.core.getTasks():
+            if isallowed or task['user'] == useriden:
+                yield task
+
+    async def _methTaskKill(self, prefix):
+        useriden = self.runt.user.iden
+        isallowed = self.runt.allowed(('task', 'del'))
+
+        prefix = await s_stormtypes.tostr(prefix)
+        if not prefix:
+            mesg = 'An empty task iden prefix is not allowed.'
+            raise s_exc.StormRuntimeError(mesg=mesg, iden=prefix)
+
+        iden = None
+        async for task in self.runt.snap.core.getTasks():
+            taskiden = task['iden']
+            if (isallowed or task['user'] == useriden) and taskiden.startswith(prefix):
+                if iden is None:
+                    iden = taskiden
+                else:
+                    mesg = 'Provided iden matches more than one task.'
+                    raise s_exc.StormRuntimeError(mesg=mesg, iden=prefix)
+
+        if iden is None:
+            mesg = 'Provided iden does not match any tasks.'
+            raise s_exc.StormRuntimeError(mesg=mesg, iden=prefix)
+
+        return await self.runt.snap.core.killTask(iden)

synapse/lib/stormtypes.py

@@ -699,117 +699,6 @@ class Lib(StormType):
         async for item in self.runt.dyniter(iden, todo, gatekeys=gatekeys):
             yield item
 
-@registry.registerLib
-class LibPkg(Lib):
-    '''
-    A Storm Library for interacting with Storm Packages.
-    '''
-    _storm_locals = (
-        {'name': 'add', 'desc': 'Add a Storm Package to the Cortex.',
-         'type': {'type': 'function', '_funcname': '_libPkgAdd',
-                  'args': (
-                      {'name': 'pkgdef', 'type': 'dict', 'desc': 'A Storm Package definition.', },
-                      {'name': 'verify', 'type': 'boolean', 'default': False,
-                       'desc': 'Verify storm package signature.', },
-                  ),
-                  'returns': {'type': 'null', }}},
-        {'name': 'get', 'desc': 'Get a Storm Package from the Cortex.',
-         'type': {'type': 'function', '_funcname': '_libPkgGet',
-                  'args': (
-                      {'name': 'name', 'type': 'str', 'desc': 'A Storm Package name.', },
-                  ),
-                  'returns': {'type': 'dict', 'desc': 'The Storm package definition.', }}},
-        {'name': 'has', 'desc': 'Check if a Storm Package is available in the Cortex.',
-         'type': {'type': 'function', '_funcname': '_libPkgHas',
-                  'args': (
-                      {'name': 'name', 'type': 'str',
-                       'desc': 'A Storm Package name to check for the existence of.', },
-                  ),
-                  'returns': {'type': 'boolean',
-                              'desc': 'True if the package exists in the Cortex, False if it does not.', }}},
-        {'name': 'del', 'desc': 'Delete a Storm Package from the Cortex.',
-         'type': {'type': 'function', '_funcname': '_libPkgDel',
-                  'args': (
-                      {'name': 'name', 'type': 'str', 'desc': 'The name of the package to delete.', },
-                  ),
-                  'returns': {'type': 'null', }}},
-        {'name': 'list', 'desc': 'Get a list of Storm Packages loaded in the Cortex.',
-         'type': {'type': 'function', '_funcname': '_libPkgList',
-                  'returns': {'type': 'list', 'desc': 'A list of Storm Package definitions.', }}},
-        {'name': 'deps', 'desc': 'Verify the dependencies for a Storm Package.',
-         'type': {'type': 'function', '_funcname': '_libPkgDeps',
-                  'args': (
-                      {'name': 'pkgdef', 'type': 'dict', 'desc': 'A Storm Package definition.', },
-                  ),
-                  'returns': {'type': 'dict', 'desc': 'A dictionary listing dependencies and if they are met.', }}},
-        {'name': 'vars',
-         'desc': "Get a dictionary representing the package's persistent variables.",
-         'type': {'type': 'function', '_funcname': '_libPkgVars',
-                  'args': (
-                      {'name': 'name', 'type': 'str',
-                       'desc': 'A Storm Package name to get vars for.', },
-                  ),
-                  'returns': {'type': 'pkg:vars', 'desc': 'A dictionary representing the package variables.', }}},
-    )
-    _storm_lib_perms = (
-        {'perm': ('power-ups', '<name>', 'admin'), 'gate': 'cortex',
-         'desc': 'Controls the ability to interact with the vars for a Storm Package by name.'},
-    )
-    _storm_lib_path = ('pkg',)
-
-    def getObjLocals(self):
-        return {
-            'add': self._libPkgAdd,
-            'get': self._libPkgGet,
-            'has': self._libPkgHas,
-            'del': self._libPkgDel,
-            'list': self._libPkgList,
-            'deps': self._libPkgDeps,
-            'vars': self._libPkgVars,
-        }
-
-    async def _libPkgAdd(self, pkgdef, verify=False):
-        self.runt.confirm(('pkg', 'add'), None)
-        pkgdef = await toprim(pkgdef)
-        verify = await tobool(verify)
-        await self.runt.snap.core.addStormPkg(pkgdef, verify=verify)
-
-    @stormfunc(readonly=True)
-    async def _libPkgGet(self, name):
-        name = await tostr(name)
-        pkgdef = await self.runt.snap.core.getStormPkg(name)
-        if pkgdef is None:
-            return None
-
-        return Dict(pkgdef)
-
-    @stormfunc(readonly=True)
-    async def _libPkgHas(self, name):
-        name = await tostr(name)
-        pkgdef = await self.runt.snap.core.getStormPkg(name)
-        if pkgdef is None:
-            return False
-        return True
-
-    async def _libPkgDel(self, name):
-        self.runt.confirm(('pkg', 'del'), None)
-        await self.runt.snap.core.delStormPkg(name)
-
-    @stormfunc(readonly=True)
-    async def _libPkgList(self):
-        pkgs = await self.runt.snap.core.getStormPkgs()
-        return list(sorted(pkgs, key=lambda x: x.get('name')))
-
-    @stormfunc(readonly=True)
-    async def _libPkgDeps(self, pkgdef):
-        pkgdef = await toprim(pkgdef)
-        return await self.runt.snap.core.verifyStormPkgDeps(pkgdef)
-
-    async def _libPkgVars(self, name):
-        name = await tostr(name)
-        confirm(('power-ups', name, 'admin'))
-        return PkgVars(self.runt, name)
-
 @registry.registerLib
 class LibDmon(Lib):
     '''
@@ -1595,8 +1484,16 @@ class LibBase(Lib):
 
             if not asroot:
                 permtext = ' or '.join(('.'.join(p) for p in rootperms))
-                mesg = f'Module ({name}) requires permission: {permtext}'
-                raise s_exc.AuthDeny(mesg=mesg, user=self.runt.user.iden, username=self.runt.user.name)
+
+                match mdef.get('asroot:ondeny:import', 'deny'):
+                    case 'allow':
+                        pass
+                    case 'warn':
+                        mesg = f'Module ({name}) permissions will not be elevated. Missing permission: {permtext}.'
+                        await self.runt.warnonce(mesg, log=False)
+                    case _:
+                        mesg = f'Module ({name}) requires permission: {permtext}'
+                        raise s_exc.AuthDeny(mesg=mesg, user=self.runt.user.iden, username=self.runt.user.name)
 
         else:
             perm = ('storm', 'asroot', 'mod') + tuple(name.split('.'))
@@ -3948,22 +3845,22 @@ class LibQueue(Lib):
         {'name': 'add', 'desc': 'Add a Queue to the Cortex with a given name.',
          'type': {'type': 'function', '_funcname': '_methQueueAdd',
                   'args': (
-                      {'name': 'name', 'type': 'str', 'desc': 'The name of the queue to add.', },
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the Queue to add.', },
                   ),
                   'returns': {'type': 'queue', }}},
-        {'name': 'gen', 'desc': 'Add or get a Storm Queue in a single operation.',
+        {'name': 'gen', 'desc': 'Add or get a Queue in a single operation.',
          'type': {'type': 'function', '_funcname': '_methQueueGen',
                   'args': (
                       {'name': 'name', 'type': 'str', 'desc': 'The name of the Queue to add or get.', },
                   ),
                   'returns': {'type': 'queue', }}},
-        {'name': 'del', 'desc': 'Delete a given named Queue.',
+        {'name': 'del', 'desc': 'Delete a given Queue.',
          'type': {'type': 'function', '_funcname': '_methQueueDel',
                   'args': (
-                      {'name': 'name', 'type': 'str', 'desc': 'The name of the queue to delete.', },
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the Queue to delete.', },
                   ),
                   'returns': {'type': 'null', }}},
-        {'name': 'get', 'desc': 'Get an existing Storm Queue object.',
+        {'name': 'get', 'desc': 'Get an existing Queue.',
          'type': {'type': 'function', '_funcname': '_methQueueGet',
                   'args': (
                       {'name': 'name', 'type': 'str', 'desc': 'The name of the Queue to get.', },
@@ -3972,17 +3869,17 @@ class LibQueue(Lib):
         {'name': 'list', 'desc': 'Get a list of the Queues in the Cortex.',
          'type': {'type': 'function', '_funcname': '_methQueueList',
                   'returns': {'type': 'list',
-                              'desc': 'A list of queue definitions the current user is allowed to interact with.', }}},
+                              'desc': 'A list of Queue definitions the current user is allowed to interact with.', }}},
     )
     _storm_lib_perms = (
         {'perm': ('queue', 'add'), 'gate': 'cortex',
-         'desc': 'Permits a user to create a named queue.'},
+         'desc': 'Permits a user to create a Queue.'},
         {'perm': ('queue', 'get'), 'gate': 'queue',
-         'desc': 'Permits a user to access a queue. This allows the user to read from the queue and remove items from it.'},
+         'desc': 'Permits a user to access a Queue. This allows the user to read from the Queue and remove items from it.'},
         {'perm': ('queue', 'put'), 'gate': 'queue',
-         'desc': 'Permits a user to put items into a queue.'},
+         'desc': 'Permits a user to put items into a Queue.'},
         {'perm': ('queue', 'del'), 'gate': 'queue',
-         'desc': 'Permits a user to delete a queue.'},
+         'desc': 'Permits a user to delete a Queue.'},
     )
     _storm_lib_path = ('queue',)
 
@@ -4045,7 +3942,7 @@ class LibQueue(Lib):
 @registry.registerType
 class Queue(StormType):
     '''
-    A StormLib API instance of a named channel in the Cortex multiqueue.
+    A StormLib API instance of a named channel in the Cortex MultiQueue.
     '''
     _storm_locals = (
         {'name': 'name', 'desc': 'The name of the Queue.', 'type': 'str', },
@@ -4059,48 +3956,48 @@ class Queue(StormType):
                        'desc': 'Wait for the offset to be available before returning the item.', },
                   ),
                   'returns': {'type': 'list',
-                              'desc': 'A tuple of the offset and the item from the queue. If wait is false and '
+                              'desc': 'A tuple of the offset and the item from the Queue. If wait is false and '
                                       'the offset is not present, null is returned.', }}},
-        {'name': 'pop', 'desc': 'Pop a item from the Queue at a specific offset.',
+        {'name': 'pop', 'desc': 'Pop an item from the Queue at a specific offset.',
          'type': {'type': 'function', '_funcname': '_methQueuePop',
                   'args': (
                       {'name': 'offs', 'type': 'int', 'default': None,
-                        'desc': 'Offset to pop the item from. If not specified, the first item in the queue will be'
+                        'desc': 'Offset to pop the item from. If not specified, the first item in the Queue will be'
                                 ' popped.', },
                       {'name': 'wait', 'type': 'boolean', 'default': False,
                         'desc': 'Wait for an item to be available to pop.'},
                   ),
                   'returns': {'type': 'list',
-                              'desc': 'The offset and item popped from the queue. If there is no item at the '
-                                      'offset or the  queue is empty and wait is false, it returns null.', }}},
-        {'name': 'put', 'desc': 'Put an item into the queue.',
+                              'desc': 'The offset and item popped from the Queue. If there is no item at the '
+                                      'offset or the Queue is empty and wait is false, it returns null.', }}},
+        {'name': 'put', 'desc': 'Put an item into the Queue.',
          'type': {'type': 'function', '_funcname': '_methQueuePut',
                   'args': (
-                      {'name': 'item', 'type': 'prim', 'desc': 'The item being put into the queue.', },
+                      {'name': 'item', 'type': 'prim', 'desc': 'The item being put into the Queue.', },
                   ),
-                  'returns': {'type': 'int', 'desc': 'The queue offset of the item.'}}},
+                  'returns': {'type': 'int', 'desc': 'The Queue offset of the item.'}}},
         {'name': 'puts', 'desc': 'Put multiple items into the Queue.',
          'type': {'type': 'function', '_funcname': '_methQueuePuts',
                   'args': (
                       {'name': 'items', 'type': 'list', 'desc': 'The items to put into the Queue.', },
                   ),
-                  'returns': {'type': 'int', 'desc': 'The queue offset of the first item.'}}},
+                  'returns': {'type': 'int', 'desc': 'The Queue offset of the first item.'}}},
         {'name': 'gets', 'desc': 'Get multiple items from the Queue as a iterator.',
          'type': {'type': 'function', '_funcname': '_methQueueGets',
                   'args': (
-                      {'name': 'offs', 'type': 'int', 'desc': 'The offset to retrieve an items from.', 'default': 0, },
+                      {'name': 'offs', 'type': 'int', 'desc': 'The offset to retrieve items from.', 'default': 0, },
                       {'name': 'wait', 'type': 'boolean', 'default': True,
                        'desc': 'Wait for the offset to be available before returning the item.', },
                       {'name': 'cull', 'type': 'boolean', 'default': False,
                        'desc': 'Culls items up to, but not including, the specified offset.', },
-                      {'name': 'size', 'type': 'int', 'desc': 'The maximum number of items to yield',
+                      {'name': 'size', 'type': 'int', 'desc': 'The maximum number of items to yield.',
                        'default': None, },
                   ),
                   'returns': {'name': 'Yields', 'type': 'list', 'desc': 'Yields tuples of the offset and item.', }}},
-        {'name': 'cull', 'desc': 'Remove items from the queue up to, and including, the offset.',
+        {'name': 'cull', 'desc': 'Remove items from the Queue up to, and including, the offset.',
          'type': {'type': 'function', '_funcname': '_methQueueCull',
                   'args': (
-                      {'name': 'offs', 'type': 'int', 'desc': 'The offset which to cull records from the queue.', },
+                      {'name': 'offs', 'type': 'int', 'desc': 'The offset which to cull records from the Queue.', },
                   ),
                   'returns': {'type': 'null', }}},
         {'name': 'size', 'desc': 'Get the number of items in the Queue.',
@@ -6088,45 +5985,6 @@ class LibVars(Lib):
     async def _libVarsType(self, valu):
         return await totype(valu)
 
-@registry.registerType
-class PkgVars(Prim):
-    '''
-    The Storm deref/setitem/iter convention on top of pkg vars information.
-    '''
-    _storm_typename = 'pkg:vars'
-    _ismutable = True
-
-    def __init__(self, runt, valu, path=None):
-        Prim.__init__(self, valu, path=path)
-        self.runt = runt
-
-    def _reqPkgAdmin(self):
-        confirm(('power-ups', self.valu, 'admin'))
-
-    @stormfunc(readonly=True)
-    async def deref(self, name):
-        self._reqPkgAdmin()
-        name = await tostr(name)
-        return await self.runt.snap.core.getStormPkgVar(self.valu, name)
-
-    async def setitem(self, name, valu):
-        self._reqPkgAdmin()
-        name = await tostr(name)
-
-        if valu is undef:
-            await self.runt.snap.core.popStormPkgVar(self.valu, name)
-            return
-
-        valu = await toprim(valu)
-        await self.runt.snap.core.setStormPkgVar(self.valu, name, valu)
-
-    @stormfunc(readonly=True)
-    async def iter(self):
-        self._reqPkgAdmin()
-        async for name, valu in self.runt.snap.core.iterStormPkgVars(self.valu):
-            yield name, valu
-            await asyncio.sleep(0)
-
 @registry.registerType
 class Query(Prim):
     '''
@@ -7837,7 +7695,8 @@ class Layer(Prim):
 
         layr = self.runt.snap.core.reqLayer(self.valu.get('iden'))
 
-        self.runt.confirm(('layer', 'edits', 'read'), gateiden=layr.iden)
+        if not self.runt.allowed(('layer', 'edits', 'read'), gateiden=layr.iden):
+            self.runt.confirm(('layer', 'read'), gateiden=layr.iden)
 
         if reverse:
             wait = False
@@ -10439,5 +10298,10 @@ async def totype(valu, basetypes=False) -> str:
 async def typeerr(name, reqt):
     if not isinstance(name, reqt):
         styp = await totype(name, basetypes=True)
-        mesg = f"Expected value of type '{reqt}', got '{styp}' with value {name}."
+
+        reqtname = str(reqt)
+        if (clsname := getattr(reqt, '__name__')):
+            reqtname = clsname
+
+        mesg = f"Expected value of type '{reqtname}', got '{styp}' with value {name}."
         return s_exc.StormRuntimeError(mesg=mesg, name=name, type=styp)

synapse/lib/trigger.py

@@ -136,26 +136,28 @@ class Triggers:
         finally:
             RecursionDepth.reset(token)
 
-    async def runNodeAdd(self, node):
+    async def runNodeAdd(self, node, useriden):
+        vars = {'auto': {'opts': {'user': useriden}}}
         with self._recursion_check():
-            [await trig.execute(node) for trig in self.nodeadd.get(node.form.name, ())]
+            [await trig.execute(node, vars=vars) for trig in self.nodeadd.get(node.form.name, ())]
 
-    async def runNodeDel(self, node):
+    async def runNodeDel(self, node, useriden):
+        vars = {'auto': {'opts': {'user': useriden}}}
         with self._recursion_check():
-            [await trig.execute(node) for trig in self.nodedel.get(node.form.name, ())]
+            [await trig.execute(node, vars=vars) for trig in self.nodedel.get(node.form.name, ())]
 
-    async def runPropSet(self, node, prop, oldv):
+    async def runPropSet(self, node, prop, oldv, useriden):
         vars = {'propname': prop.name, 'propfull': prop.full,
-                'auto': {'opts': {'propname': prop.name, 'propfull': prop.full, }},
+                'auto': {'opts': {'propname': prop.name, 'propfull': prop.full, 'user': useriden}},
                 }
         with self._recursion_check():
             [await trig.execute(node, vars=vars) for trig in self.propset.get(prop.full, ())]
             if prop.univ is not None:
                 [await trig.execute(node, vars=vars) for trig in self.propset.get(prop.univ.full, ())]
 
-    async def runTagAdd(self, node, tag):
+    async def runTagAdd(self, node, tag, useriden):
 
-        vars = {'tag': tag, 'auto': {'opts': {'tag': tag}}}
+        vars = {'tag': tag, 'auto': {'opts': {'tag': tag, 'user': useriden}}}
         with self._recursion_check():
 
             for trig in self.tagadd.get((node.form.name, tag), ()):
@@ -176,10 +178,10 @@ class Triggers:
                 for _, trig in globs.get(tag):
                     await trig.execute(node, vars=vars)
 
-    async def runTagDel(self, node, tag):
+    async def runTagDel(self, node, tag, useriden):
 
         vars = {'tag': tag,
-                'auto': {'opts': {'tag': tag}},
+                'auto': {'opts': {'tag': tag, 'user': useriden}},
                 }
         with self._recursion_check():
 
@@ -201,11 +203,11 @@ class Triggers:
                 for _, trig in globs.get(tag):
                     await trig.execute(node, vars=vars)
 
-    async def runEdgeAdd(self, n1, verb, n2):
+    async def runEdgeAdd(self, n1, verb, n2, useriden):
         n1form = n1.form.name if n1 else None
         n2form = n2.form.name if n2 else None
         n2iden = n2.iden() if n2 else None
-        varz = {'auto': {'opts': {'verb': verb, 'n2iden': n2iden}}}
+        varz = {'auto': {'opts': {'verb': verb, 'n2iden': n2iden, 'user': useriden}}}
         with self._recursion_check():
             cachekey = (n1form, verb, n2form)
             cached = self.edgeaddcache.get(cachekey)
@@ -251,11 +253,11 @@ class Triggers:
             for trig in cached:
                 await trig.execute(n1, vars=varz)
 
-    async def runEdgeDel(self, n1, verb, n2):
+    async def runEdgeDel(self, n1, verb, n2, useriden):
         n1form = n1.form.name if n1 else None
         n2form = n2.form.name if n2 else None
         n2iden = n2.iden() if n2 else None
-        varz = {'auto': {'opts': {'verb': verb, 'n2iden': n2iden}}}
+        varz = {'auto': {'opts': {'verb': verb, 'n2iden': n2iden, 'user': useriden}}}
         with self._recursion_check():
             cachekey = (n1form, verb, n2form)
             cached = self.edgedelcache.get(cachekey)

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, 221, 0)
+version = (2, 223, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '6ae7cd60524df7dc861bb91fe25309999eba6d70'
+commit = 'b40e64b75fa2820856ad138b8ad9f8c4b6e9547e'

synapse/lib/view.py

@@ -58,6 +58,9 @@ class ViewApi(s_cell.CellApi):
     @s_cell.adminapi()
     async def saveNodeEdits(self, edits, meta):
         meta['link:user'] = self.user.iden
+        user = meta.get('user', '')
+        if not s_common.isguid(user):
+            raise s_exc.BadArg(mesg=f'Meta argument requires user key to be a guid, got {user=}')
         async with await self.view.snap(user=self.user) as snap:
             return await snap.saveNodeEdits(edits, meta)
 
@@ -1584,57 +1587,57 @@ class View(s_nexus.Pusher):  # type: ignore
         layer = self.layers[0]
         await layer.confirmLayerEditPerms(user, layer.iden, delete=True)
 
-    async def runTagAdd(self, node, tag, valu):
+    async def runTagAdd(self, node, tag, valu, useriden):
 
         if self.core.migration or self.core.safemode:
             return
 
         # Run any trigger handlers
-        await self.triggers.runTagAdd(node, tag)
+        await self.triggers.runTagAdd(node, tag, useriden)
 
-    async def runTagDel(self, node, tag, valu):
+    async def runTagDel(self, node, tag, valu, useriden):
 
         if self.core.migration or self.core.safemode:
             return
 
-        await self.triggers.runTagDel(node, tag)
+        await self.triggers.runTagDel(node, tag, useriden)
 
-    async def runNodeAdd(self, node):
+    async def runNodeAdd(self, node, useriden):
 
         if self.core.migration or self.core.safemode:
             return
 
-        await self.triggers.runNodeAdd(node)
+        await self.triggers.runNodeAdd(node, useriden)
 
-    async def runNodeDel(self, node):
+    async def runNodeDel(self, node, useriden):
 
         if self.core.migration or self.core.safemode:
             return
 
-        await self.triggers.runNodeDel(node)
+        await self.triggers.runNodeDel(node, useriden)
 
-    async def runPropSet(self, node, prop, oldv):
+    async def runPropSet(self, node, prop, oldv, useriden):
         '''
         Handle when a prop set trigger event fired
         '''
         if self.core.migration or self.core.safemode:
             return
 
-        await self.triggers.runPropSet(node, prop, oldv)
+        await self.triggers.runPropSet(node, prop, oldv, useriden)
 
-    async def runEdgeAdd(self, n1, edge, n2):
+    async def runEdgeAdd(self, n1, edge, n2, useriden):
 
         if self.core.migration or self.core.safemode:
             return
 
-        await self.triggers.runEdgeAdd(n1, edge, n2)
+        await self.triggers.runEdgeAdd(n1, edge, n2, useriden)
 
-    async def runEdgeDel(self, n1, edge, n2):
+    async def runEdgeDel(self, n1, edge, n2, useriden):
 
         if self.core.migration or self.core.safemode:
             return
 
-        await self.triggers.runEdgeDel(n1, edge, n2)
+        await self.triggers.runEdgeDel(n1, edge, n2, useriden)
 
     async def addTrigger(self, tdef):
         '''

synapse/models/files.py

@@ -390,7 +390,7 @@ class FileModule(s_module.CoreModule):
                     'doc': 'The typecode for the resource.',
                 }),
 
-                ('pe:langid', ('int', {'enums': s_l_pe.getLangCodes()}), {
+                ('pe:langid', ('int', {'min': 0, 'max': 0xffff, 'enums': s_l_pe.getLangCodes(), 'enums:strict': False}), {
                     'doc': 'The PE language id.',
                 }),
 

synapse/models/orgs.py

@@ -729,6 +729,9 @@ class OuModule(s_module.CoreModule):
 
                     ('ext:id', ('str', {'strip': True}), {
                         'doc': 'An external identifier for the technique.'}),
+
+                    ('parent', ('ou:technique', {}), {
+                        'doc': 'The parent technique for the technique.'}),
                 )),
                 ('ou:technique:taxonomy', {}, ()),
                 ('ou:orgtype', {}, ()),

synapse/tests/test_cortex.py

@@ -426,7 +426,7 @@ class CortexTest(s_t_utils.SynTest):
                 self.len(1, await core00.nodes('test:str=foo', opts=view00opts))
 
                 layr = core01.getLayer(layr01iden)
-                await layr.storNodeEdits((), {})
+                await layr.storNodeEdits((), {'user': s_common.guid()})
 
     async def test_cortex_must_upgrade(self):