synapse 2.176.0__py311-none-any.whl → 2.177.0__py311-none-any.whl

synapse/lib/stormlib/model.py

@@ -919,8 +919,63 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                        'desc': 'Do not copy nodedata to the risk:vulnerable node.'},
                  ),
                  'returns': {'type': 'list', 'desc': 'A list of idens for the risk:vulnerable nodes.'}}},
+        {'name': 'inetSslCertToTlsServerCert', 'desc': '''
+            Create a inet:tls:servercert node from the provided inet:ssl:cert node.
+
+            Edits will be made to the inet:tls:servercert node in the current write layer.
+
+            Tags, tag properties, edges, and node data will be copied
+            to the inet:tls:servercert node. However, existing tag properties and
+            node data will not be overwritten.
+        ''',
+        'type': {'type': 'function', '_funcname': '_storm_query',
+                 'args': (
+                      {'name': 'n', 'type': 'node', 'desc': 'The inet:ssl:cert node to migrate.'},
+                      {'name': 'nodata', 'type': 'bool', 'default': False,
+                       'desc': 'Do not copy nodedata to the inet:tls:servercert node.'},
+                 ),
+                 'returns': {'type': 'node', 'desc': 'The newly created inet:tls:servercert node.'}}},
+
     )
     _storm_lib_path = ('model', 'migration', 's')
+    _storm_query = '''
+        function inetSslCertToTlsServerCert(n, nodata=$lib.false) {
+            $form = $n.form()
+            if ($form != 'inet:ssl:cert') {
+                $mesg = `$lib.model.migration.s.inetSslCertToTlsServerCert() only accepts inet:ssl:cert nodes, not {$form}`
+                $lib.raise(BadArg, $mesg)
+            }
+
+            $server = $n.props.server
+            $sha256 = { yield $n -> file:bytes -> hash:sha256 }
+
+            if $sha256 {
+
+                yield $lib.gen.inetTlsServerCertByServerAndSha256($server, $sha256)
+
+            } else {
+
+                // File doesn't have a :sha256, try to lift/create a crypto:x509:node based on the file link
+                $crypto = { yield $n -> file:bytes -> crypto:x509:cert:file }
+                if (not $crypto) {
+                    $crypto = {[ crypto:x509:cert=($n.props.file,) :file=$n.props.file ]}
+                }
+
+                [ inet:tls:servercert=($server, $crypto) ]
+
+            }
+
+            [ .seen ?= $n.props.".seen" ]
+
+            $lib.model.migration.copyTags($n, $node, overwrite=$lib.false)
+            $lib.model.migration.copyEdges($n, $node)
+            if (not $nodata) {
+                $lib.model.migration.copyData($n, $node, overwrite=$lib.false)
+            }
+
+            return($node)
+        }
+    '''
 
     def getObjLocals(self):
         return {

synapse/lib/stormlib/modelext.py

@@ -77,6 +77,27 @@ class LibModelExt(s_stormtypes.Lib):
                       {'name': 'model', 'type': 'dict', 'desc': 'A model dictionary from getExtModel().', },
                   ),
                   'returns': {'type': 'boolean'}}},
+        {'name': 'addEdge', 'desc': 'Add an extended edge definition to the data model.',
+         'type': {'type': 'function', '_funcname': 'addEdge',
+                  'args': (
+                      {'name': 'n1form', 'type': 'str',
+                       'desc': 'The form of the n1 node. May be "*" or null to specify "any".'},
+                      {'name': 'verb', 'type': 'str', 'desc': 'The edge verb, which must begin with "_".'},
+                      {'name': 'n2form', 'type': 'str',
+                       'desc': 'The form of the n2 node. May be "*" or null to specify "any".'},
+                      {'name': 'edgeinfo', 'type': 'dict', 'desc': 'A Synapse edge info dictionary.'},
+                  ),
+                  'returns': {'type': 'null'}}},
+        {'name': 'delEdge', 'desc': 'Remove an extended edge definition from the data model.',
+         'type': {'type': 'function', '_funcname': 'delEdge',
+                  'args': (
+                      {'name': 'n1form', 'type': 'str',
+                       'desc': 'The form of the n1 node. May be "*" or null to specify "any".'},
+                      {'name': 'verb', 'type': 'str', 'desc': 'The edge verb, which must begin with "_".'},
+                      {'name': 'n2form', 'type': 'str',
+                       'desc': 'The form of the n2 node. May be "*" or null to specify "any".'},
+                  ),
+                  'returns': {'type': 'null'}}},
     )
     _storm_lib_path = ('model', 'ext')
 
@@ -92,6 +113,8 @@ class LibModelExt(s_stormtypes.Lib):
             'delTagProp': self.delTagProp,
             'getExtModel': self.getExtModel,
             'addExtModel': self.addExtModel,
+            'addEdge': self.addEdge,
+            'delEdge': self.delEdge,
         }
 
     # TODO type docs in the new convention
@@ -163,3 +186,40 @@ class LibModelExt(s_stormtypes.Lib):
     async def addExtModel(self, model):
         model = await s_stormtypes.toprim(model)
         return await self.runt.snap.core.addExtModel(model)
+
+    async def addEdge(self, n1form, verb, n2form, edgeinfo):
+        verb = await s_stormtypes.tostr(verb)
+        n1form = await s_stormtypes.tostr(n1form, noneok=True)
+        n2form = await s_stormtypes.tostr(n2form, noneok=True)
+        edgeinfo = await s_stormtypes.toprim(edgeinfo)
+
+        if not (s_grammar.isEdgeVerb(verb) and verb.islower()):
+            mesg = f'Invalid edge verb {verb}'
+            raise s_exc.BadEdgeDef(mesg=mesg, n1form=n1form, verb=verb, n2form=n2form)
+
+        if n1form == '*':
+            n1form = None
+
+        if n2form == '*':
+            n2form = None
+
+        s_stormtypes.confirm(('model', 'edge', 'add'))
+        await self.runt.snap.core.addEdge((n1form, verb, n2form), edgeinfo)
+
+    async def delEdge(self, n1form, verb, n2form):
+        verb = await s_stormtypes.tostr(verb)
+        n1form = await s_stormtypes.tostr(n1form, noneok=True)
+        n2form = await s_stormtypes.tostr(n2form, noneok=True)
+
+        if not (s_grammar.isEdgeVerb(verb) and verb.islower()):
+            mesg = f'Invalid edge verb {verb}'
+            raise s_exc.BadEdgeDef(mesg=mesg, n1form=n1form, verb=verb, n2form=n2form)
+
+        if n1form == '*':
+            n1form = None
+
+        if n2form == '*':
+            n2form = None
+
+        s_stormtypes.confirm(('model', 'edge', 'del'))
+        await self.runt.snap.core.delEdge((n1form, verb, n2form))

synapse/lib/stormlib/tabular.py

@@ -0,0 +1,212 @@
+import copy
+import textwrap
+import itertools
+
+import synapse.exc as s_exc
+import synapse.common as s_common
+import synapse.lib.schemas as s_schemas
+import synapse.lib.stormtypes as s_stormtypes
+
+justers = {
+    'left': str.ljust,
+    'center': str.center,
+    'right': str.rjust,
+}
+
+@s_stormtypes.registry.registerLib
+class LibTabular(s_stormtypes.Lib):
+    '''
+    A Storm Library for creating printable tables.
+    '''
+    _storm_locals = (
+        {'name': 'printer', 'desc': '''
+        Construct a new printer.
+
+        Examples:
+            Create a simple table using the default separators::
+
+                $conf = ({
+                    "columns": [
+                        {"name": "Year", "width": 4},
+                        {"name": "Author", "width": 20},
+                        {"name": "Title", "width": 12},
+                    ]
+                })
+
+                $printer = $lib.tabular.printer($conf)
+
+                $lib.print($printer.header())
+
+                for ($year, $author, $title, $publisher) in $data {
+                    $lib.print($printer.row(($year, $author, $title))
+                }
+
+            Create a configuration with custom separators and column options::
+
+                $conf = ({
+                    "separators": {
+                        "row:outline": true,
+                        "column:outline": true,
+                        "header:row": "#",
+                        "data:row": "*",
+                        "column": "+",
+                    },
+                    "columns": [
+                        {"name": "Year", "width": 4, "justify": "right"},
+                        {"name": "Author", "width": 20, "justify": "center"},
+                        {"name": "Title", "width": 12, "overflow": "wrap"},
+                    ]
+                })
+
+                $printer = $lib.tabular.printer($conf)
+        ''',
+         'type': {'type': 'function', '_funcname': '_methPrinter',
+                  'args': (
+                      {'name': 'conf', 'type': 'dict',
+                       'desc': 'The table configuration dictionary.'},
+                  ),
+                  'returns': {'type': 'tabular:printer',
+                              'desc': 'The newly constructed tabular:printer.'}}},
+        {'name': 'schema', 'desc': '''
+        Get a copy of the table configuration schema.
+
+        Examples:
+            Print a human-readable version of the schema::
+
+                $schema = $lib.tabular.schema()
+                $lib.print($lib.yaml.save($schema))
+        ''',
+         'type': {'type': 'function', '_funcname': '_methSchema',
+                  'returns': {'type': 'dict',
+                              'desc': 'The table configuration schema.'}}},
+    )
+    _storm_lib_path = ('tabular',)
+
+    def getObjLocals(self):
+        return {
+            'printer': self._methPrinter,
+            'schema': self._methSchema,
+        }
+
+    async def _methSchema(self):
+        return copy.deepcopy(s_schemas.tabularConfSchema)
+
+    async def _methPrinter(self, conf):
+        conf = await s_stormtypes.toprim(conf)
+        conf.setdefault('separators', {})
+        conf = s_schemas.reqValidTabularConf(conf)
+        return TabularPrinter(self.runt, conf)
+
+@s_stormtypes.registry.registerType
+class TabularPrinter(s_stormtypes.StormType):
+    '''
+    A Storm object for printing tabular data using a defined configuration.
+    '''
+    _storm_typename = 'tabular:printer'
+    _storm_locals = (
+        {'name': 'row', 'desc': 'Create a new row string from a data list.',
+         'type': {'type': 'function', '_funcname': 'row',
+                  'args': (
+                      {'name': 'data', 'type': 'list',
+                       'desc': 'The data to create the row from; length must match the number of configured columns.'},
+                  ),
+                  'returns': {'type': 'str', 'desc': 'The row string.'}}},
+        {'name': 'header',
+         'desc': 'Create a header row string.',
+         'type': {'type': 'function', '_funcname': 'header',
+                  'returns': {'type': 'str', 'desc': 'The header row string.'}}},
+    )
+
+    def __init__(self, runt, conf):
+        s_stormtypes.StormType.__init__(self, None)
+        self.runt = runt
+        self.conf = conf
+
+        self.firstrow = True
+
+        self.seprconf = conf['separators']
+
+        self.colconf = conf['columns']
+        self.colcnt = len(self.colconf)
+        self.colwidths = [coldef.get('width') or len(coldef['name']) for coldef in self.colconf]
+
+        self.locls.update({
+            'row': self.row,
+            'header': self.header,
+        })
+
+    def _formatRowLine(self, lineitems, pad=' '):
+        sepr = self.seprconf['column']
+        endstr = sepr if self.seprconf['column:outline'] else ''
+        return f'{endstr}{pad}{f"{pad}{sepr}{pad}".join(lineitems)}{pad}{endstr}'
+
+    def _makeSeparatorRowStr(self, rowsepr):
+        if rowsepr:
+            lineitems = (width * rowsepr for width in self.colwidths)
+            return self._formatRowLine(lineitems, pad=rowsepr)
+        return None
+
+    def _makeDataRowStrs(self, values):
+
+        items = []
+        for coldef, valu in zip(self.colconf, values):
+            width = coldef.get('width')
+            valu = str(valu) if valu is not None else ''
+
+            if width is None:
+                if coldef['newlines'] == 'split':
+                    items.append(valu.split('\n'))
+                else:
+                    items.append([valu.replace('\n', ' ')])
+                continue
+
+            valu = valu.replace('\n', ' ')
+
+            if len(valu) <= width:
+                items.append([justers[coldef['justify']](valu, width)])
+                continue
+
+            if coldef['overflow'] == 'trim':
+                items.append([s_common.trimText(valu, n=width)])
+                continue
+
+            items.append([justers[coldef['justify']](item, width) for item in textwrap.wrap(valu, width)])
+
+        rowstrs = []
+        for lineitems in itertools.zip_longest(*items, fillvalue=None):
+            lineitems = ([item or self.colwidths[i] * ' ' for i, item in enumerate(lineitems)])
+            rowstrs.append(self._formatRowLine(lineitems))
+
+        return rowstrs
+
+    async def header(self):
+        rowstrs = self._makeDataRowStrs([col['name'] for col in self.colconf])
+
+        if seprstr := self._makeSeparatorRowStr(self.seprconf['header:row']):
+            rowstrs.append(seprstr)
+            if self.seprconf['row:outline']:
+                rowstrs.insert(0, seprstr)
+
+        return '\n'.join(rowstrs)
+
+    async def row(self, data):
+        data = await s_stormtypes.toprim(data)
+
+        if not isinstance(data, (list, tuple)):
+            raise s_exc.BadArg(mesg='tabular:printer row() requires a list argument')
+
+        if len(data) != self.colcnt:
+            mesg = 'tabular:printer row() requires data length to equal column count'
+            raise s_exc.BadArg(mesg=mesg, length=len(data), column_length=self.colcnt)
+
+        rowstrs = self._makeDataRowStrs(data)
+
+        if seprstr := self._makeSeparatorRowStr(self.seprconf['data:row']):
+            if self.seprconf['row:outline']:
+                rowstrs.append(seprstr)
+            elif self.firstrow:
+                self.firstrow = False
+            else:
+                rowstrs.insert(0, seprstr)
+
+        return '\n'.join(rowstrs)

synapse/lib/stormtypes.py

@@ -4138,7 +4138,7 @@ class LibBase64(Lib):
             if urlsafe:
                 return base64.urlsafe_b64decode(valu)
             return base64.b64decode(valu)
-        except binascii.Error as e:
+        except (binascii.Error, TypeError) as e:
             mesg = f'Error during base64 decoding - {str(e)}: {s_common.trimText(repr(valu))}'
             raise s_exc.StormRuntimeError(mesg=mesg, urlsafe=urlsafe) from None
 
@@ -7532,6 +7532,9 @@ class View(Prim):
         {'name': 'wipeLayer', 'desc': 'Delete all nodes and nodedata from the write layer. Triggers will be run.',
          'type': {'type': 'function', '_funcname': '_methWipeLayer',
                   'returns': {'type': 'null', }}},
+        {'name': 'swapLayer', 'desc': 'Swaps the top layer for a fresh one and deletes the old layer.',
+         'type': {'type': 'function', '_funcname': '_methSwapLayer',
+                  'returns': {'type': 'null', }}},
         {'name': 'addNode', 'desc': '''Transactionally add a single node and all it's properties. If any validation fails, no changes are made.''',
          'type': {'type': 'function', '_funcname': 'addNode',
                   'args': (
@@ -7717,6 +7720,7 @@ class View(Prim):
             'addNode': self.addNode,
             'getEdges': self._methGetEdges,
             'wipeLayer': self._methWipeLayer,
+            'swapLayer': self._methSwapLayer,
             'addNodeEdits': self._methAddNodeEdits,
             'getEdgeVerbs': self._methGetEdgeVerbs,
             'getFormCounts': self._methGetFormcount,
@@ -8017,6 +8021,15 @@ class View(Prim):
         view = self.runt.snap.core.getView(viewiden)
         await view.wipeLayer(useriden=useriden)
 
+    async def _methSwapLayer(self):
+
+        view = self._reqView()
+
+        self.runt.reqAdmin(gateiden=view.iden)
+        self.runt.confirm(('layer', 'del'), gateiden=view.layers[0].iden)
+
+        await view.swapLayer()
+
     async def getMerges(self):
         view = self._reqView()
         async for merge in view.getMerges():

synapse/lib/trigger.py

@@ -494,7 +494,7 @@ class Trigger:
             await self.view.core.getStormQuery(valu)
 
         self.tdef[name] = valu
-        await self.view.trigdict.set(self.iden, self.tdef)
+        self.view.trigdict.set(self.iden, self.tdef)
 
     def get(self, name):
         return self.tdef.get(name)

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, 176, 0)
+version = (2, 177, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '16ee721a6b7221344eaf946c3ab4602dda546b1a'
+commit = 'b7da795aeb690020e38e99dc5aa1f505cdc2d659'

synapse/lib/view.py

@@ -79,18 +79,17 @@ class View(s_nexus.Pusher):  # type: ignore
     '''
     snapctor = s_snap.Snap.anit
 
-    async def __anit__(self, core, node):
+    async def __anit__(self, core, vdef):
         '''
         Async init the view.
 
         Args:
             core (Cortex):  The cortex that owns the view.
-            node (HiveNode): The hive node containing the view info.
+            vdef (dict): The dictionary containing the view definition.
         '''
-        self.node = node
-        self.iden = node.name()
+        self.iden = vdef.get('iden')
         self.bidn = s_common.uhex(self.iden)
-        self.info = await node.dict()
+        self.info = vdef
 
         self.core = core
         self.dirn = s_common.gendir(core.dirn, 'views', self.iden)
@@ -101,11 +100,10 @@ class View(s_nexus.Pusher):  # type: ignore
 
         self.trigqueue = self.viewslab.getSeqn('trigqueue')
 
-        trignode = await node.open(('triggers',))
-        self.trigdict = await trignode.dict()
+        self.trigdict = self.core.cortexdata.getSubKeyVal(f'view:{self.iden}:trigger:')
 
         self.triggers = s_trigger.Triggers(self)
-        for _, tdef in self.trigdict.items():
+        for tdef in self.trigdict.values():
             try:
                 await self.triggers.load(tdef)
 
@@ -268,12 +266,14 @@ class View(s_nexus.Pusher):  # type: ignore
             return
 
         self.merging = True
-        await self.info.set('merging', True)
+        self.info['merging'] = True
+        self.core.viewdefs.set(self.iden, self.info)
 
         layr = self.layers[0]
 
         layr.readonly = True
-        await layr.layrinfo.set('readonly', True)
+        layr.layrinfo['readonly'] = True
+        self.core.layerdefs.set(layr.iden, layr.layrinfo)
 
         merge = self.getMergeRequest()
         votes = [vote async for vote in self.getMergeVotes()]
@@ -490,10 +490,11 @@ class View(s_nexus.Pusher):  # type: ignore
         await self._delMergeMeta()
 
         self.parent = None
-        await self.info.pop('parent')
+        if self.info.pop('parent', None) is not None:
+            self.core.viewdefs.set(self.iden, self.info)
 
-        await self.core.feedBeholder('view:set', {'iden': self.iden, 'name': 'parent', 'valu': None},
-                                     gates=[self.iden, self.layers[0].iden])
+            await self.core.feedBeholder('view:set', {'iden': self.iden, 'name': 'parent', 'valu': None},
+                                         gates=[self.iden, self.layers[0].iden])
 
     async def mergeStormIface(self, name, todo):
         '''
@@ -707,15 +708,17 @@ class View(s_nexus.Pusher):  # type: ignore
         # Add all of the bottom view's layers.
         layers.extend(view.layers)
 
-        self.layers = layers
         layridens = [layr.iden for layr in layers]
-        await self.info.set('layers', layridens)
 
-        await self.core.feedBeholder('view:setlayers', {'iden': self.iden, 'layers': layridens}, gates=[self.iden, layridens[0]])
+        self.layers = layers
+        self.info['layers'] = layridens
+        self.core.viewdefs.set(self.iden, self.info)
+
+        await self.core.feedBeholder('view:setlayers', {'iden': self.iden, 'layers': layridens}, gates=[self.iden, self.layers[0].iden])
 
     async def pack(self):
         d = {'iden': self.iden}
-        d.update(self.info.pack())
+        d.update(self.info)
 
         layrinfo = [await lyr.pack() for lyr in self.layers]
         d['layers'] = layrinfo
@@ -855,6 +858,7 @@ class View(s_nexus.Pusher):  # type: ignore
 
     async def _initViewLayers(self):
 
+        self.layers = []
         for iden in self.info.get('layers'):
 
             layr = self.core.layers.get(iden)
@@ -1121,7 +1125,8 @@ class View(s_nexus.Pusher):  # type: ignore
                 raise s_exc.BadArg(mesg=mesg)
 
             self.parent = parent
-            await self.info.set(name, valu)
+            self.info[name] = valu
+            self.core.viewdefs.set(self.iden, self.info)
 
             await self._calcForkLayers()
 
@@ -1137,7 +1142,7 @@ class View(s_nexus.Pusher):  # type: ignore
                 # enforce ( which will need to be done very carefully to prevent
                 # existing non-compliant values from causing issues with existing views )
                 if valu is not None:
-                    vdef = self.info.pack()
+                    vdef = s_msgpack.deepcopy(self.info)
                     vdef['quorum'] = s_msgpack.deepcopy(valu)
                     s_schemas.reqValidView(vdef)
                 else:
@@ -1148,14 +1153,24 @@ class View(s_nexus.Pusher):  # type: ignore
                             await view._delMergeRequest()
 
             if valu is None:
-                await self.info.pop(name)
+                self.info.pop(name, None)
             else:
-                await self.info.set(name, valu)
+                self.info[name] = valu
+
+            self.core.viewdefs.set(self.iden, self.info)
 
         await self.core.feedBeholder('view:set', {'iden': self.iden, 'name': name, 'valu': valu},
                                      gates=[self.iden, self.layers[0].iden])
         return valu
 
+    async def _setLayerIdens(self, idens):
+        # this may only be called from within a nexus handler...
+        self.info['layers'] = idens
+        self.core.viewdefs.set(self.iden, self.info)
+        await self._initViewLayers()
+        await self.core.feedBeholder('view:set', {'iden': self.iden, 'name': 'layers', 'valu': idens},
+                                     gates=[self.iden, self.layers[0].iden])
+
     async def addLayer(self, layriden, indx=None):
         if any(layriden == layr.iden for layr in self.layers):
             raise s_exc.DupIden(mesg='May not have the same layer in a view twice')
@@ -1184,7 +1199,9 @@ class View(s_nexus.Pusher):  # type: ignore
         else:
             self.layers.insert(indx, layr)
 
-        await self.info.set('layers', [lyr.iden for lyr in self.layers])
+        self.info['layers'] = [lyr.iden for lyr in self.layers]
+        self.core.viewdefs.set(self.iden, self.info)
+
         await self.core.feedBeholder('view:addlayer', {'iden': self.iden, 'layer': layriden, 'indx': indx}, gates=[self.iden, layriden])
         self.core._calcViewsByLayer()
 
@@ -1212,7 +1229,9 @@ class View(s_nexus.Pusher):  # type: ignore
         self.invalid = None
         self.layers = layrs
 
-        await self.info.set('layers', layers)
+        self.info['layers'] = layers
+        self.core.viewdefs.set(self.iden, self.info)
+
         await self.core.feedBeholder('view:setlayers', {'iden': self.iden, 'layers': layers}, gates=[self.iden, layers[0]])
 
         await self._calcChildViews()
@@ -1242,7 +1261,8 @@ class View(s_nexus.Pusher):  # type: ignore
 
                 # convert layers to a list of idens...
                 lids = [layr.iden for layr in layers]
-                await child.info.set('layers', lids)
+                child.info['layers'] = lids
+                self.core.viewdefs.set(child.iden, child.info)
 
                 await self.core.feedBeholder('view:setlayers', {'iden': child.iden, 'layers': lids}, gates=[child.iden, lids[0]])
 
@@ -1300,8 +1320,9 @@ class View(s_nexus.Pusher):  # type: ignore
         await self.core._addView(vdef)
 
         forkiden = vdef.get('iden')
+        self.info['parent'] = forkiden
         self.parent = self.core.reqView(forkiden)
-        await self.info.set('parent', forkiden)
+        self.core.viewdefs.set(self.iden, self.info)
 
         mesg = {'iden': self.iden, 'name': 'parent', 'valu': forkiden}
         await self.core.feedBeholder('view:set', mesg, gates=[self.iden, self.layers[0].iden])
@@ -1386,6 +1407,12 @@ class View(s_nexus.Pusher):  # type: ignore
             async for nodeedits in fromlayr.iterLayerNodeEdits():
                 await self.parent.storNodeEdits([nodeedits], meta)
 
+    async def swapLayer(self):
+        oldlayr = self.layers[0]
+        newlayr = await self.core._twinLayer(oldlayr)
+        await self.core.swapLayer(oldlayr.iden, newlayr.iden)
+        await self.core.delLayer(oldlayr.iden)
+
     async def wipeLayer(self, useriden=None):
         '''
         Delete the data in the write layer by generating del nodeedits.
@@ -1549,7 +1576,7 @@ class View(s_nexus.Pusher):  # type: ignore
 
         trig = await self.triggers.load(tdef)
 
-        await self.trigdict.set(trig.iden, tdef)
+        self.trigdict.set(trig.iden, tdef)
         await self.core.auth.addAuthGate(trig.iden, 'trigger')
         await user.setAdmin(True, gateiden=tdef.get('iden'), logged=False)
 
@@ -1581,7 +1608,7 @@ class View(s_nexus.Pusher):  # type: ignore
             return
 
         await self.core.feedBeholder('trigger:del', {'iden': trig.iden, 'view': trig.view.iden}, gates=[trig.iden])
-        await self.trigdict.pop(trig.iden)
+        self.trigdict.pop(trig.iden)
         await self.core.auth.delAuthGate(trig.iden)
 
     @s_nexus.Pusher.onPushAuto('trigger:set')
@@ -1607,7 +1634,7 @@ class View(s_nexus.Pusher):  # type: ignore
         Note: this does not delete any layer storage.
         '''
         await self.fini()
-        await self.node.pop()
+        await self.trigdict.truncate()
         await self._wipeViewMeta()
         shutil.rmtree(self.dirn, ignore_errors=True)
 

synapse/models/base.py

@@ -59,6 +59,10 @@ class BaseModule(s_module.CoreModule):
                 ('meta:ruleset', ('guid', {}), {
                     'doc': 'A set of rules linked with -(has)> edges.'}),
 
+                ('meta:rule:type:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy for meta:rule types.'}),
+
                 ('meta:rule', ('guid', {}), {
                     'doc': 'A generic rule linked to matches with -(matches)> edges.'}),
 
@@ -257,9 +261,12 @@ class BaseModule(s_module.CoreModule):
                         'doc': 'The time the ruleset was most recently modified.'}),
                 )),
 
+                ('meta:rule:type:taxonomy', {}, ()),
                 ('meta:rule', {}, (
                     ('name', ('str', {'lower': True, 'onespace': True}), {
                         'doc': 'A name for the rule.'}),
+                    ('type', ('meta:rule:type:taxonomy', {}), {
+                        'doc': 'The rule type.'}),
                     ('desc', ('str', {}), {
                         'disp': {'hint': 'text'},
                         'doc': 'A description of the rule.'}),