synapse 2.168.0__tar.gz → 2.169.0__tar.gz

{synapse-2.168.0/synapse.egg-info → synapse-2.169.0}/PKG-INFO

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

{synapse-2.168.0 → synapse-2.169.0}/pyproject.toml

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

{synapse-2.168.0 → synapse-2.169.0}/synapse/cortex.py

@@ -573,14 +573,6 @@ class CoreApi(s_cell.CellApi):
     async def delStormDmon(self, iden):
         return await self.cell.delStormDmon(iden)
 
-    @s_cell.adminapi(log=True)
-    async def enableMigrationMode(self): # pragma: no cover
-        s_common.deprdate('CoreApi.enableMigrationMode', '2024-05-05')
-
-    @s_cell.adminapi(log=True)
-    async def disableMigrationMode(self): # pragma: no cover
-        s_common.deprdate('CoreApi.disableMigrationMode', '2024-05-05')
-
     @s_cell.adminapi()
     async def cloneLayer(self, iden, ldef=None):
 
@@ -1350,6 +1342,17 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
              'ex': 'node.prop.del.inet:ipv4.asn',
              'desc': 'Controls removing a specific property from a form of node in a layer.'},
 
+            {'perm': ('node', 'data', 'set'), 'gate': 'layer',
+             'desc': 'Permits a user to set node data in a given layer.'},
+            {'perm': ('node', 'data', 'set', '<key>'), 'gate': 'layer',
+              'ex': 'node.data.set.hehe',
+             'desc': 'Permits a user to set node data in a given layer for a specific key.'},
+            {'perm': ('node', 'data', 'pop'), 'gate': 'layer',
+             'desc': 'Permits a user to remove node data in a given layer.'},
+            {'perm': ('node', 'data', 'pop', '<key>'), 'gate': 'layer',
+             'ex': 'node.data.pop.hehe',
+             'desc': 'Permits a user to remove node data in a given layer for a specific key.'},
+
             {'perm': ('pkg', 'add'), 'gate': 'cortex',
              'desc': 'Controls access to adding storm packages.'},
             {'perm': ('pkg', 'del'), 'gate': 'cortex',

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/agenda.py

@@ -831,6 +831,9 @@ class Agenda(s_base.Base):
                 'view': appt.view,
                 'mirror': appt.pool,
                 'vars': {'auto': {'iden': appt.iden, 'type': 'cron'}},
+                '_loginfo': {
+                    'cron': appt.iden
+                }
             }
             opts = self.core._initStormOpts(opts)
 

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/cell.py

@@ -1295,14 +1295,20 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
 
     async def _onBootOptimize(self):
 
+        bdir = s_common.genpath(self.dirn, 'backups')
         tdir = s_common.gendir(self.dirn, 'tmp')
         tdev = os.stat(tdir).st_dev
 
+        logger.warning('Collecting LMDB files for onboot optimization.')
+
         lmdbs = []
         for (root, dirs, files) in os.walk(self.dirn):
             for dirname in dirs:
                 filepath = os.path.join(root, dirname, 'data.mdb')
                 if os.path.isfile(filepath):
+                    if filepath.startswith(bdir):
+                        logger.debug(f'Skipping backup file {filepath}')
+                        continue
                     if os.stat(filepath).st_dev != tdev:
                         logger.warning(f'Unable to run onboot:optimize, {filepath} is not on the same volume as {tdir}')
                         return
@@ -2891,24 +2897,10 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         self.onfini(self.dmon.fini)
 
     async def _initCellHive(self):
-        isnew = not self.slab.dbexists('hive')
-
         db = self.slab.initdb('hive')
         hive = await s_hive.SlabHive.anit(self.slab, db=db, nexsroot=self.getCellNexsRoot())
         self.onfini(hive)
 
-        if isnew:
-            path = os.path.join(self.dirn, 'hiveboot.yaml')
-            if os.path.isfile(path):
-                s_common.deprdate('Initial hive config from hiveboot.yaml', '2024-05-05')
-                logger.debug(f'Loading cell hive from {path}')
-                tree = s_common.yamlload(path)
-                if tree is not None:
-                    # Pack and unpack the tree to avoid tuple/list issues
-                    # for in-memory structures.
-                    tree = s_common.tuplify(tree)
-                    await hive.loadHiveTree(tree)
-
         return hive
 
     async def _initCellSlab(self, readonly=False):

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/httpapi.py

@@ -1354,6 +1354,9 @@ class ExtApiHandler(StormHandler):
             'user': useriden,
             'vars': varz,
             'view': adef.get('view'),
+            '_loginfo': {
+                'httpapi': iden
+            }
         }
 
         query = '\n'.join((self.storm_prefix, storm))

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/snap.py

@@ -717,7 +717,9 @@ class Snap(s_base.Base):
 
         show_storage = False
 
-        self.core._logStormQuery(text, user, info={'mode': opts.get('mode', 'storm'), 'view': self.view.iden})
+        info = opts.get('_loginfo', {})
+        info.update({'mode': opts.get('mode', 'storm'), 'view': self.view.iden})
+        self.core._logStormQuery(text, user, info=info)
 
         # { form: ( embedprop, ... ) }
         embeds = opts.get('embeds')

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/stormlib/model.py

@@ -1,6 +1,7 @@
 import synapse.exc as s_exc
 import synapse.common as s_common
 
+import synapse.lib.node as s_node
 import synapse.lib.cache as s_cache
 import synapse.lib.stormtypes as s_stormtypes
 
@@ -692,3 +693,122 @@ class LibModelDeprecated(s_stormtypes.Lib):
         todo = s_common.todo('setDeprLock', name, locked)
         gatekeys = ((self.runt.user.iden, ('model', 'deprecated', 'lock'), None),)
         await self.runt.dyncall('cortex', todo, gatekeys=gatekeys)
+
+@s_stormtypes.registry.registerLib
+class LibModelMigration(s_stormtypes.Lib):
+    '''
+    A Storm library containing migration tools.
+    '''
+    _storm_locals = (
+        {'name': 'copyData', 'desc': 'Copy node data from the src node to the dst node.',
+         'type': {'type': 'function', '_funcname': '_methCopyData',
+                  'args': (
+                      {'name': 'src', 'type': 'node', 'desc': 'The node to copy data from.', },
+                      {'name': 'dst', 'type': 'node', 'desc': 'The node to copy data to.', },
+                      {'name': 'overwrite', 'type': 'boolean', 'default': False,
+                       'desc': 'Copy data even if the key exists on the destination node.', },
+                  ),
+                  'returns': {'type': 'null', }}},
+        {'name': 'copyEdges', 'desc': 'Copy edges from the src node to the dst node.',
+         'type': {'type': 'function', '_funcname': '_methCopyEdges',
+                  'args': (
+                      {'name': 'src', 'type': 'node', 'desc': 'The node to copy edges from.', },
+                      {'name': 'dst', 'type': 'node', 'desc': 'The node to copy edges to.', },
+                  ),
+                  'returns': {'type': 'null', }}},
+        {'name': 'copyTags', 'desc': 'Copy tags, tag timestamps, and tag props from the src node to the dst node.',
+         'type': {'type': 'function', '_funcname': '_methCopyTags',
+                  'args': (
+                      {'name': 'src', 'type': 'node', 'desc': 'The node to copy tags from.', },
+                      {'name': 'dst', 'type': 'node', 'desc': 'The node to copy tags to.', },
+                      {'name': 'overwrite', 'type': 'boolean', 'default': False,
+                       'desc': 'Copy tag property value even if the property exists on the destination node.', },
+                  ),
+                  'returns': {'type': 'null', }}},
+    )
+    _storm_lib_path = ('model', 'migration')
+
+    def getObjLocals(self):
+        return {
+            'copyData': self._methCopyData,
+            'copyEdges': self._methCopyEdges,
+            'copyTags': self._methCopyTags,
+        }
+
+    async def _methCopyData(self, src, dst, overwrite=False):
+
+        if not isinstance(src, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyData() source argument must be a node.')
+        if not isinstance(dst, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyData() dest argument must be a node.')
+
+        overwrite = await s_stormtypes.tobool(overwrite)
+
+        async with self.runt.snap.getEditor() as editor:
+
+            proto = editor.loadNode(dst)
+
+            async for name in src.iterDataKeys():
+                if overwrite or not await dst.hasData(name):
+                    self.runt.layerConfirm(('node', 'data', 'set', name))
+                    valu = await src.getData(name)
+                    await proto.setData(name, valu)
+
+    async def _methCopyEdges(self, src, dst):
+
+        if not isinstance(src, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyEdges() source argument must be a node.')
+        if not isinstance(dst, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyEdges() dest argument must be a node.')
+
+        snap = self.runt.snap
+
+        async with snap.getEditor() as editor:
+
+            proto = editor.loadNode(dst)
+            verbs = set()
+
+            async for (verb, n2iden) in src.iterEdgesN1():
+
+                if verb not in verbs:
+                    self.runt.layerConfirm(('node', 'edge', 'add', verb))
+                    verbs.add(verb)
+
+                if await snap.getNodeByBuid(s_common.uhex(n2iden)) is not None:
+                    await proto.addEdge(verb, n2iden)
+
+            dstiden = s_common.ehex(dst.buid)
+
+            async for (verb, n1iden) in src.iterEdgesN2():
+
+                if verb not in verbs:
+                    self.runt.layerConfirm(('node', 'edge', 'add', verb))
+                    verbs.add(verb)
+
+                n1proto = await editor.getNodeByBuid(s_common.uhex(n1iden))
+                if n1proto is not None:
+                    await n1proto.addEdge(verb, dstiden)
+
+    async def _methCopyTags(self, src, dst, overwrite=False):
+
+        if not isinstance(src, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyTags() source argument must be a node.')
+        if not isinstance(dst, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyTags() dest argument must be a node.')
+
+        overwrite = await s_stormtypes.tobool(overwrite)
+
+        snap = self.runt.snap
+
+        async with snap.getEditor() as editor:
+
+            proto = editor.loadNode(dst)
+
+            for name, valu in src.tags.items():
+                self.runt.layerConfirm(('node', 'tag', 'add', *name.split('.')))
+                await proto.addTag(name, valu=valu)
+
+            for tagname, tagprops in src.tagprops.items():
+                for propname, valu in tagprops.items():
+                    if overwrite or not dst.hasTagProp(tagname, propname):
+                        await proto.setTagProp(tagname, propname, valu) # use tag perms

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/stormtypes.py

@@ -1604,8 +1604,12 @@ class LibBase(Lib):
                 continue
             vals.append(arg)
 
+        if len(vals) < 1:
+            mesg = '$lib.min() must have at least one argument or a list containing at least one value.'
+            raise s_exc.StormRuntimeError(mesg=mesg)
+
         ints = [await toint(x) for x in vals]
-        return min(*ints)
+        return min(ints)
 
     @stormfunc(readonly=True)
     async def _max(self, *args):
@@ -1618,8 +1622,12 @@ class LibBase(Lib):
                 continue
             vals.append(arg)
 
+        if len(vals) < 1:
+            mesg = '$lib.max() must have at least one argument or a list containing at least one value.'
+            raise s_exc.StormRuntimeError(mesg=mesg)
+
         ints = [await toint(x) for x in vals]
-        return max(*ints)
+        return max(ints)
 
     @staticmethod
     async def _get_mesg(mesg, **kwargs):

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/version.py

@@ -223,6 +223,6 @@ def reqVersion(valu, reqver,
 ##############################################################################
 # The following are touched during the release process by bumpversion.
 # Do not modify these directly.
-version = (2, 168, 0)
+version = (2, 169, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = 'd07eb2560a6e5e025ce9c20efaafe5571a55856c'
+commit = '41421efcf40bb7655af3f90cb7d6d335247fc726'

{synapse-2.168.0 → synapse-2.169.0}/synapse/lib/view.py

@@ -868,20 +868,16 @@ class View(s_nexus.Pusher):  # type: ignore
 
             self.layers.append(layr)
 
-    async def eval(self, text, opts=None, log_info=None):
+    async def eval(self, text, opts=None):
         '''
         Evaluate a storm query and yield Nodes only.
         '''
         opts = self.core._initStormOpts(opts)
         user = self.core._userFromOpts(opts)
 
-        if log_info is None:
-            log_info = {}
-
-        log_info['mode'] = opts.get('mode', 'storm')
-        log_info['view'] = self.iden
-
-        self.core._logStormQuery(text, user, info=log_info)
+        info = opts.get('_loginfo', {})
+        info.update({'mode': opts.get('mode', 'storm'), 'view': self.iden})
+        self.core._logStormQuery(text, user, info=info)
 
         taskiden = opts.get('task')
         taskinfo = {'query': text, 'view': self.iden}
@@ -997,8 +993,9 @@ class View(s_nexus.Pusher):  # type: ignore
                                 count += 1
 
                         else:
-                            self.core._logStormQuery(text, user,
-                                                     info={'mode': opts.get('mode', 'storm'), 'view': self.iden})
+                            info = opts.get('_loginfo', {})
+                            info.update({'mode': opts.get('mode', 'storm'), 'view': self.iden})
+                            self.core._logStormQuery(text, user, info=info)
                             async for item in snap.storm(text, opts=opts, user=user):
                                 count += 1
 

{synapse-2.168.0 → synapse-2.169.0}/synapse/tests/test_lib_agenda.py

@@ -1,3 +1,4 @@
+import json
 import asyncio
 import hashlib
 import datetime
@@ -156,7 +157,7 @@ class AgendaTest(s_t_utils.SynTest):
         newts = ar.nexttime(now)
         self.eq(newts, datetime.datetime(year=2018, month=12, day=5, hour=7, minute=2, tzinfo=tz.utc).timestamp())
 
-    async def test_agenda(self):
+    async def test_agenda_base(self):
         MONO_DELT = 1543827303.0
         unixtime = datetime.datetime(year=2018, month=12, day=5, hour=7, minute=0, tzinfo=tz.utc).timestamp()
 
@@ -382,8 +383,21 @@ class AgendaTest(s_t_utils.SynTest):
                 self.true(appt.enabled)
                 self.eq(0, appt.startcount)
 
-                unixtime = datetime.datetime(year=2019, month=2, day=13, hour=10, minute=16, tzinfo=tz.utc).timestamp()
-                self.eq((12, 'bar'), await asyncio.wait_for(core.callStorm('return($lib.queue.gen(visi).pop(wait=$lib.true))'), timeout=5))
+                # Ensure structured logging captures the cron iden value
+                core.stormlog = True
+                with self.getStructuredAsyncLoggerStream('synapse.storm') as stream:
+                    unixtime = datetime.datetime(year=2019, month=2, day=13, hour=10, minute=16,
+                                                 tzinfo=tz.utc).timestamp()
+                    self.eq((12, 'bar'), await asyncio.wait_for(core.callStorm('return($lib.queue.gen(visi).pop(wait=$lib.true))'), timeout=5))
+                core.stormlog = False
+
+                data = stream.getvalue()
+                raw_mesgs = [m for m in data.split('\n') if m]
+                msgs = [json.loads(m) for m in raw_mesgs]
+                msgs = [m for m in msgs if m['text'] == '$lib.queue.gen(visi).put(bar)']
+                self.gt(len(msgs), 0)
+                for m in msgs:
+                    self.eq(m.get('cron'), appt.iden)
 
                 self.eq(1, appt.startcount)
 

{synapse-2.168.0 → synapse-2.169.0}/synapse/tests/test_lib_cell.py

@@ -496,52 +496,6 @@ class CellTest(s_t_utils.SynTest):
                 with self.raises(s_exc.AuthDeny):
                     await prox.setCellUser(visiiden)
 
-    async def test_cell_hiveboot(self):
-
-        with self.getTestDir() as dirn:
-
-            tree = {
-                'kids': {
-                    'hehe': {'value': 'haha'},
-                }
-            }
-
-            bootpath = os.path.join(dirn, 'hiveboot.yaml')
-
-            s_common.yamlsave(tree, bootpath)
-
-            with warnings.catch_warnings(record=True) as warns:
-                async with self.getTestCell(s_cell.Cell, dirn=dirn) as cell:
-                    self.eq('haha', await cell.hive.get(('hehe',)))
-
-                self.isin('Initial hive config from hiveboot.yaml', str(warns[0].message))
-
-            # test that the file does not load again
-            tree['kids']['redballoons'] = {'value': 99}
-            s_common.yamlsave(tree, bootpath)
-
-            async with self.getTestCell(s_cell.Cell, dirn=dirn) as cell:
-                self.none(await cell.hive.get(('redballoons',)))
-
-        # Do a full hive dump/load
-        with self.getTestDir() as dirn:
-            dir0 = s_common.genpath(dirn, 'cell00')
-            dir1 = s_common.genpath(dirn, 'cell01')
-            async with self.getTestCell(s_cell.Cell, dirn=dir0, conf={'auth:passwd': 'root'}) as cell00:
-                await cell00.hive.set(('beeps',), [1, 2, 'three'])
-
-                tree = await cell00.saveHiveTree()
-                s_common.yamlsave(tree, dir1, 'hiveboot.yaml')
-                with s_common.genfile(dir1, 'cell.guid') as fd:
-                    _ = fd.write(cell00.iden.encode())
-
-            async with self.getTestCell(s_cell.Cell, dirn=dir1) as cell01:
-                resp = await cell01.hive.get(('beeps',))
-                self.isinstance(resp, tuple)
-                self.eq(resp, (1, 2, 'three'))
-
-            self.eq(cell00.iden, cell01.iden)
-
     async def test_cell_getinfo(self):
         async with self.getTestCore() as cell:
             cell.COMMIT = 'mycommit'
@@ -2243,8 +2197,8 @@ class CellTest(s_t_utils.SynTest):
                 async with self.getTestCore(dirn=dirn, conf=conf) as core:
                     pass
 
-                stream.seek(0)
-                self.isin('onboot optimization complete!', stream.read())
+            stream.seek(0)
+            self.isin('onboot optimization complete!', stream.read())
 
             stat01 = os.stat(lmdbfile)
             self.ne(stat00.st_ino, stat01.st_ino)
@@ -2266,10 +2220,25 @@ class CellTest(s_t_utils.SynTest):
                     async with self.getTestCore(dirn=dirn, conf=conf) as core:
                         pass
 
-                    stream.seek(0)
-                    buf = stream.read()
-                    self.notin('onboot optimization complete!', buf)
-                    self.isin('not on the same volume', buf)
+                stream.seek(0)
+                buf = stream.read()
+                self.notin('onboot optimization complete!', buf)
+                self.isin('not on the same volume', buf)
+
+            # Local backup files are skipped
+            async with self.getTestCore(dirn=dirn) as core:
+                await core.runBackup()
+
+            with self.getAsyncLoggerStream('synapse.lib.cell') as stream:
+
+                conf = {'onboot:optimize': True}
+                async with self.getTestCore(dirn=dirn, conf=conf) as core:
+                    pass
+
+            stream.seek(0)
+            buf = stream.read()
+            self.isin('Skipping backup file', buf)
+            self.isin('onboot optimization complete!', buf)
 
     async def test_cell_gc(self):
         async with self.getTestCore() as core:

{synapse-2.168.0 → synapse-2.169.0}/synapse/tests/test_lib_stormlib_cortex.py

@@ -281,6 +281,18 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
                 self.eq(data.get('json'), 'err')
                 self.eq(data.get('path'), 'echo/words/wOw')
 
+                # Storm query logging includes the httpapi iden in structlog data
+                core.stormlog = True
+                with self.getStructuredAsyncLoggerStream('synapse.storm', 'Executing storm query') as stream:
+                    resp = await sess.get(url)
+                    self.eq(resp.status, 200)
+                    self.true(await stream.wait(timeout=12))
+                data = stream.getvalue()
+                raw_mesgs = [m for m in data.split('\n') if m]
+                msgs = [json.loads(m) for m in raw_mesgs]
+                self.eq(msgs[0].get('httpapi'), echoiden)
+                core.stormlog = False
+
                 # Sad paths on the $request methods
                 q = '''$api = $lib.cortex.httpapi.add(testpath02)
                 $api.methods.get = ${ $request.sendcode(200) $request.sendheaders('beep beep') }

{synapse-2.168.0 → synapse-2.169.0}/synapse/tests/test_lib_stormlib_model.py

@@ -1,4 +1,5 @@
 import synapse.exc as s_exc
+import synapse.lib.time as s_time
 import synapse.lib.layer as s_layer
 
 import synapse.tests.utils as s_test
@@ -295,3 +296,107 @@ class StormlibModelTest(s_test.SynTest):
 
                 self.stormIsInWarn('.pdep is not yet locked', mesgs)
                 self.stormNotInWarn('test:dep:easy.pdep is not yet locked', mesgs)
+
+    async def test_stormlib_model_migration(self):
+
+        async with self.getTestCore() as core:
+
+            nodes = await core.nodes('[ test:str=src test:str=dst test:str=deny test:str=other ]')
+            otheriden = nodes[3].iden()
+
+            lowuser = await core.auth.addUser('lowuser')
+            aslow = {'user': lowuser.iden}
+
+            # copy node data
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=src $lib.model.migration.copyData($node, newp)'))
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=dst $lib.model.migration.copyData(newp, $node)'))
+
+            nodes = await core.nodes('''
+                test:str=src
+                $node.data.set(a, a-src)
+                $node.data.set(b, b-src)
+                $n=$node -> {
+                    test:str=dst
+                    $node.data.set(a, a-dst)
+                    $lib.model.migration.copyData($n, $node)
+                }
+            ''')
+            self.len(1, nodes)
+            self.sorteq(
+                [('a', 'a-dst'), ('b', 'b-src')],
+                [data async for data in nodes[0].iterData()]
+            )
+
+            nodes = await core.nodes('''
+                test:str=src $n=$node -> {
+                    test:str=dst
+                    $lib.model.migration.copyData($n, $node, overwrite=$lib.true)
+                }
+            ''')
+            self.len(1, nodes)
+            self.sorteq(
+                [('a', 'a-src'), ('b', 'b-src')],
+                [data async for data in nodes[0].iterData()]
+            )
+
+            q = 'test:str=src $n=$node -> { test:str=deny $lib.model.migration.copyData($n, $node) }'
+            await self.asyncraises(s_exc.AuthDeny, core.nodes(q, opts=aslow))
+
+            # copy edges
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=src $lib.model.migration.copyEdges($node, newp)'))
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=dst $lib.model.migration.copyEdges(newp, $node)'))
+
+            nodes = await core.nodes('''
+                test:str=src
+                [ <(foo)+ { test:str=other } +(bar)> { test:str=other } ]
+                $n=$node -> {
+                    test:str=dst
+                    $lib.model.migration.copyEdges($n, $node)
+                }
+            ''')
+            self.len(1, nodes)
+            self.eq([('bar', otheriden)], [edge async for edge in nodes[0].iterEdgesN1()])
+            self.eq([('foo', otheriden)], [edge async for edge in nodes[0].iterEdgesN2()])
+
+            q = 'test:str=src $n=$node -> { test:str=deny $lib.model.migration.copyEdges($n, $node) }'
+            await self.asyncraises(s_exc.AuthDeny, core.nodes(q, opts=aslow))
+
+            # copy tags
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=src $lib.model.migration.copyTags($node, newp)'))
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=dst $lib.model.migration.copyTags(newp, $node)'))
+
+            await core.nodes('$lib.model.ext.addTagProp(test, (str, ({})), ({}))')
+
+            nodes = await core.nodes('''
+                test:str=src
+                [ +#foo=(2010, 2012) +#foo.bar +#baz:test=src ]
+                $n=$node -> {
+                    test:str=dst
+                    [ +#foo=(2010, 2011) +#baz:test=dst ]
+                    $lib.model.migration.copyTags($n, $node)
+                }
+            ''')
+            self.len(1, nodes)
+            self.sorteq([
+                ('baz', (None, None)),
+                ('foo', (s_time.parse('2010'), s_time.parse('2012'))),
+                ('foo.bar', (None, None))
+            ], nodes[0].getTags())
+            self.eq([], nodes[0].getTagProps('foo'))
+            self.eq([], nodes[0].getTagProps('foo.bar'))
+            self.eq([('test', 'dst')], [(k, nodes[0].getTagProp('baz', k)) for k in nodes[0].getTagProps('baz')])
+
+            nodes = await core.nodes('''
+                test:str=src $n=$node -> {
+                    test:str=dst
+                    $lib.model.migration.copyTags($n, $node, overwrite=$lib.true)
+                }
+            ''')
+            self.len(1, nodes)
+            self.eq([('test', 'src')], [(k, nodes[0].getTagProp('baz', k)) for k in nodes[0].getTagProps('baz')])
+
+            q = 'test:str=src $n=$node -> { test:str=deny $lib.model.migration.copyTags($n, $node) }'
+            await self.asyncraises(s_exc.AuthDeny, core.nodes(q, opts=aslow))

{synapse-2.168.0 → synapse-2.169.0}/synapse/tests/test_lib_stormtypes.py

@@ -575,6 +575,32 @@ class StormTypesTest(s_test.SynTest):
             self.len(1, nodes)
             self.eq(30, nodes[0].ndef[1])
 
+            # $lib.min / $lib.max behavior with 1 item
+            ret = await core.callStorm('$x = ([(1234)]) return ( $lib.min($x) )')
+            self.eq(ret, 1234)
+
+            ret = await core.callStorm('return ( $lib.min(1234) )')
+            self.eq(ret, 1234)
+
+            ret = await core.callStorm('$x = ([(1234)]) return ( $lib.max($x) )')
+            self.eq(ret, 1234)
+
+            ret = await core.callStorm('return ( $lib.max(1234) )')
+            self.eq(ret, 1234)
+
+            # $lib.min / $lib.max behavior with 0 items
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$lib.max()')
+
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$l=() $lib.max($l)')
+
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$lib.min()')
+
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$l=() $lib.min($l)')
+
             nodes = await core.nodes('[ inet:asn=$lib.len(asdf) ]')
             self.len(1, nodes)
             self.eq(4, nodes[0].ndef[1])

{synapse-2.168.0 → synapse-2.169.0/synapse.egg-info}/PKG-INFO

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