synapse 2.201.0__tar.gz → 2.202.0__tar.gz

{synapse-2.201.0/synapse.egg-info → synapse-2.202.0}/PKG-INFO

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

{synapse-2.201.0 → synapse-2.202.0}/pyproject.toml

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

{synapse-2.201.0 → synapse-2.202.0}/synapse/cortex.py

@@ -5874,38 +5874,45 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
         if self.stormpool is None:  # pragma: no cover
             return None
 
-        if self.stormpool.size() == 0:
+        size = self.stormpool.size()
+        if size == 0:
             logger.warning('Storm query mirror pool is empty, running query locally.')
             return None
 
-        proxy = None
+        for _ in range(size):
 
-        try:
-            timeout = self.stormpoolopts.get('timeout:connection')
-            proxy = await self.stormpool.proxy(timeout=timeout)
-            proxyname = proxy._ahainfo.get('name')
-            if proxyname is not None and proxyname == self.ahasvcname:
-                # we are part of the pool and were selected. Convert to local use.
-                return None
+            try:
+                timeout = self.stormpoolopts.get('timeout:connection')
+                proxy = await self.stormpool.proxy(timeout=timeout)
+                proxyname = proxy._ahainfo.get('name')
+                if proxyname is not None and proxyname == self.ahasvcname:
+                    # we are part of the pool and were selected. Convert to local use.
+                    return None
+
+            except TimeoutError:
+                logger.warning('Timeout waiting for pool mirror proxy.')
+                continue
+
+            try:
+
+                curoffs = opts.setdefault('nexsoffs', await self.getNexsIndx() - 1)
+                miroffs = await s_common.wait_for(proxy.getNexsIndx(), timeout) - 1
+                if (delta := curoffs - miroffs) <= MAX_NEXUS_DELTA:
+                    return proxy
 
-            curoffs = opts.setdefault('nexsoffs', await self.getNexsIndx() - 1)
-            miroffs = await s_common.wait_for(proxy.getNexsIndx(), timeout) - 1
-            if (delta := curoffs - miroffs) > MAX_NEXUS_DELTA:
-                mesg = (f'Pool mirror [{proxyname}] Nexus offset delta too large '
-                        f'({delta} > {MAX_NEXUS_DELTA}), running query locally.')
+                mesg = f'Pool mirror [{proxyname}] is too far out of sync. Skipping.'
                 logger.warning(mesg, extra=await self.getLogExtra(delta=delta, mirror=proxyname, mirror_offset=miroffs))
-                return None
 
-            return proxy
+            except s_exc.IsFini:
+                mesg = f'Proxy for pool mirror [{proxyname}] was shutdown. Skipping.'
+                logger.warning(mesg, extra=await self.getLogExtra(mirror=proxyname))
 
-        except (TimeoutError, s_exc.IsFini):
-            if proxy is None:
-                logger.warning('Timeout waiting for pool mirror, running query locally.')
-            else:
-                mesg = f'Timeout waiting for pool mirror [{proxyname}] Nexus offset, running query locally.'
+            except TimeoutError:
+                mesg = f'Timeout waiting for pool mirror [{proxyname}] Nexus offset.'
                 logger.warning(mesg, extra=await self.getLogExtra(mirror=proxyname))
-                await proxy.fini()
-            return None
+
+        logger.warning('Pool members exhausted. Running query locally.', extra=await self.getLogExtra())
+        return None
 
     async def storm(self, text, opts=None):
 

{synapse-2.201.0 → synapse-2.202.0}/synapse/lib/base.py

@@ -128,7 +128,7 @@ class Base:
 
         self.isfini = False
         self.anitted = True  # For assertion purposes
-        self.finievt = None
+        self.finievt = asyncio.Event()
         self.entered = False
 
         # hold a weak ref to other bases we should fini if they
@@ -431,10 +431,7 @@ class Base:
         self._syn_funcs.clear()
         self._fini_funcs.clear()
 
-        fevt = self.finievt
-
-        if fevt is not None:
-            fevt.set()
+        self.finievt.set()
 
         return 0
 
@@ -468,13 +465,6 @@ class Base:
             base.waitfini(timeout=30)
 
         '''
-
-        if self.isfini:
-            return True
-
-        if self.finievt is None:
-            self.finievt = asyncio.Event()
-
         return await s_coro.event_wait(self.finievt, timeout)
 
     def schedCoro(self, coro):

{synapse-2.201.0 → synapse-2.202.0}/synapse/lib/cell.py

@@ -2711,6 +2711,12 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
             raise s_exc.BadArg(mesg=mesg, arg='path', valu=path)
         await self._streamBackupArchive(path, user, name)
 
+    async def _removeStreamingBackup(self, path):
+        logger.debug(f'Removing {path}')
+        await s_coro.executor(shutil.rmtree, path, ignore_errors=True)
+        logger.debug(f'Removed {path}')
+        self.backupstreaming = False
+
     async def iterNewBackupArchive(self, user, name=None, remove=False):
 
         if self.backupstreaming:
@@ -2728,23 +2734,13 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
                 mesg = 'Backup with name already exists'
                 raise s_exc.BadArg(mesg=mesg)
 
-            try:
-                await self.runBackup(name)
-            except Exception:
-                if remove:
-                    logger.debug(f'Removing {path}')
-                    await s_coro.executor(shutil.rmtree, path, ignore_errors=True)
-                    logger.debug(f'Removed {path}')
-                raise
-
+            await self.runBackup(name)
             await self._streamBackupArchive(path, user, name)
 
         finally:
             if remove:
-                logger.debug(f'Removing {path}')
-                await s_coro.executor(shutil.rmtree, path, ignore_errors=True)
-                logger.debug(f'Removed {path}')
-                self.backupstreaming = False
+                self.removetask = asyncio.create_task(self._removeStreamingBackup(path))
+                await asyncio.shield(self.removetask)
 
     async def isUserAllowed(self, iden, perm, gateiden=None, default=False):
         user = self.auth.user(iden)  # type: s_auth.User

{synapse-2.201.0 → synapse-2.202.0}/synapse/lib/parser.py

@@ -75,7 +75,7 @@ terminalEnglishMap = {
     'MODSET': '+= or -=',
     'MODSETMULTI': '++= or --=',
     'NONQUOTEWORD': 'unquoted value',
-    'NOT': 'not',
+    'NOTOP': 'not',
     'NULL': 'null',
     'NUMBER': 'number',
     'OCTNUMBER': 'number',
@@ -134,6 +134,7 @@ terminalEnglishMap = {
     '_LPARNOSPACE': '(',
     '_MATCHHASH': '#',
     '_MATCHHASHWILD': '#',
+    '_NOT': 'not',
     '_RETURN': 'return',
     '_REVERSE': 'reverse',
     '_RIGHTJOIN': '-+>',

{synapse-2.201.0 → synapse-2.202.0}/synapse/lib/storm.lark

@@ -437,7 +437,8 @@ _cond: notcond | "(" _condexpr ")"
     | condsubq | arraycond
     | _varvalu | _reqdollarexprs
 
-notcond: "not" _cond
+_NOT: "not"
+notcond: _NOT _cond
 
 hasrelpropcond: relprop | univprop
 relpropcond: relpropvalue _cmpr _valu
@@ -627,15 +628,15 @@ OCTNUMBER.1: /
 /x
 
 BOOL.2: /(true|false)(?=$|[\s\),\]}\|\=])/
-NULL.2: "null"
-NOT.2: "not"
+NULL.2: /null(?=$|[\s\),\]}\|\=])/
+NOTOP.2: /not(?=$|[\s\),\]}\|\=])/
 OR.2: "or"
 AND.2: "and"
 
 // $ expression rules in increasing order of precedence (modeled on Python's order)
 ?expror: exprand | expror OR exprand
 ?exprand: exprnot | exprand AND exprnot
-?exprnot: exprcmp | NOT exprcmp
+?exprnot: exprcmp | NOTOP exprcmp
 ?exprcmp: exprsum | exprcmp (CMPR | EQSPACE | EQNOSPACE) exprsum
 ?exprsum: exprproduct | exprsum (EXPRPLUS | EXPRMINUS) exprproduct
 ?exprproduct: exprunary | exprproduct (EXPRTIMES | EXPRDIVIDE | EXPRMODULO) exprunary

{synapse-2.201.0 → synapse-2.202.0}/synapse/lib/storm_format.py

@@ -57,7 +57,7 @@ TerminalPygMap = {
     'MODSET': p_t.Operator,
     'MODSETMULTI': p_t.Operator,
     'NONQUOTEWORD': p_t.Literal,
-    'NOT': p_t.Keyword,
+    'NOTOP': p_t.Operator,
     'NULL': p_t.Keyword,
     'NUMBER': p_t.Literal.Number,
     'OCTNUMBER': p_t.Literal.Number,
@@ -115,6 +115,7 @@ TerminalPygMap = {
     '_LPARNOSPACE': p_t.Punctuation,
     '_MATCHHASH': p_t.Punctuation,
     '_MATCHHASHWILD': p_t.Punctuation,
+    '_NOT': p_t.Keyword,
     '_RETURN': p_t.Keyword,
     '_REVERSE': p_t.Keyword,
     '_RIGHTJOIN': p_t.Punctuation,

{synapse-2.201.0 → synapse-2.202.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, 201, 0)
+version = (2, 202, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = 'eed8c13ff316a77ae835539215c862d052d31994'
+commit = '744d404357c48b663bd03528e35c6f0e186edb0e'

{synapse-2.201.0 → synapse-2.202.0}/synapse/telepath.py

@@ -31,6 +31,8 @@ televers = (3, 0)
 
 aha_clients = {}
 
+LINK_CULL_INTERVAL = 10
+
 async def addAhaUrl(url):
     '''
     Add (incref) an aha registry URL.
@@ -590,6 +592,10 @@ class Proxy(s_base.Base):
         valu = proxy.getFooValu(x, y)
 
     '''
+    _link_task = None
+    _link_event = asyncio.Event()
+    _all_proxies = set()
+
     async def __anit__(self, link, name):
 
         await s_base.Base.__anit__(self)
@@ -608,11 +614,15 @@ class Proxy(s_base.Base):
         self.methinfo = {}
 
         self.sess = None
+
         self.links = collections.deque()
-        self._link_poolsize = 4
+        self.alllinks = collections.deque()
+
+        self._link_add = 0      # counter for pending links being connected
+        self._links_min = 4     # low water mark for the link pool
+        self._links_max = 12    # high water mark for the link pool
 
         self.synack = None
-        self.syndone = asyncio.Event()
 
         self.handlers = {
             'task:fini': self._onTaskFini,
@@ -626,19 +636,52 @@ class Proxy(s_base.Base):
                 await item.fini()
 
             mesg = ('task:fini', {'retn': (False, ('IsFini', {}))})
-            for name, task in list(self.tasks.items()):
+            for iden, task in list(self.tasks.items()):  # pragma: no cover
                 task.reply(mesg)
-                del self.tasks[name]
+                del self.tasks[iden]
 
-            for link in self.links:
-                await link.fini()
+            # fini all the links from a different task to prevent
+            # delaying the proxy shutdown...
+            s_coro.create_task(self._finiAllLinks())
 
-            del self.syndone
-            await self.link.fini()
+            if self in self._all_proxies:
+                self._all_proxies.remove(self)
+
+            if not Proxy._all_proxies and Proxy._link_task is not None:
+                Proxy._link_task.cancel()
+                Proxy._link_task = None
+
+        Proxy._all_proxies.add(self)
 
         self.onfini(fini)
         self.link.onfini(self.fini)
 
+        if Proxy._link_task is None:
+            Proxy._link_task = s_coro.create_task(Proxy._linkLoopTask())
+
+    @classmethod
+    async def _linkLoopTask(clas):
+        while True:
+            try:
+                await s_coro.event_wait(Proxy._link_event, timeout=LINK_CULL_INTERVAL)
+
+                for proxy in list(Proxy._all_proxies):
+
+                    if proxy.isfini:
+                        continue
+
+                    # close one link per proxy per period if the number of
+                    # available links is greater than _links_max...
+                    if len(proxy.links) > proxy._links_max:
+                        link = proxy.links.popleft()
+                        await link.fini()
+                        await proxy.fire('pool:link:fini', link=link)
+
+                Proxy._link_event.clear()
+
+            except Exception:  # pragma: no cover
+                logger.exception('synapse.telepath.Proxy.linkLoopTask()')
+
     def _hasTeleFeat(self, name, vers=1):
         return self._features.get(name, 0) >= vers
 
@@ -692,6 +735,12 @@ class Proxy(s_base.Base):
 
             link = self.links.popleft()
 
+            # fire a task to replace the link if we are
+            # below the low-water mark for link count.
+            if len(self.links) + self._link_add < self._links_min:
+                self._link_add += 1
+                self.schedCoro(self._addPoolLink())
+
             if link.isfini:
                 continue
 
@@ -700,6 +749,11 @@ class Proxy(s_base.Base):
         # we need a new one...
         return await self._initPoolLink()
 
+    async def _addPoolLink(self):
+        link = await self._initPoolLink()
+        self.links.append(link)
+        self._link_add -= 1
+
     async def getPipeline(self, genr, name=None):
         '''
         Construct a proxy API call pipeline in order to make
@@ -724,8 +778,6 @@ class Proxy(s_base.Base):
 
     async def _initPoolLink(self):
 
-        # TODO loop / backoff
-
         if self.link.get('unix'):
 
             path = self.link.get('path')
@@ -739,19 +791,26 @@ class Proxy(s_base.Base):
 
             link = await s_link.connect(host, port, ssl=ssl)
 
-        self.onfini(link)
+        self.alllinks.append(link)
+        async def fini():
+            self.alllinks.remove(link)
+            if link in self.links:
+                self.links.remove(link)
+
+        link.onfini(fini)
 
         return link
 
+    async def _finiAllLinks(self):
+        for link in list(self.alllinks):
+            await link.fini()
+        await self.link.fini()
+
     async def _putPoolLink(self, link):
 
         if link.isfini:
             return
 
-        # If we've exceeded our poolsize, discard the current link.
-        if len(self.links) >= self._link_poolsize:
-            return await link.fini()
-
         self.links.append(link)
 
     def __enter__(self):
@@ -862,6 +921,7 @@ class Proxy(s_base.Base):
 
                 except GeneratorExit:
                     # if they bail early on the genr, fini the link
+                    # TODO: devise a tx/rx strategy to recover these links...
                     await link.fini()
 
             return s_coro.GenrHelp(genrloop())
@@ -1321,7 +1381,6 @@ class Client(s_base.Base):
         info.update(self._t_opts)
         self._t_proxy = await openinfo(info)
         self._t_methinfo = self._t_proxy.methinfo
-        self._t_proxy._link_poolsize = self._t_conf.get('link_poolsize', 4)
 
         async def fini():
             if self._t_named_meths:

{synapse-2.201.0 → synapse-2.202.0}/synapse/tests/test_cortex.py

@@ -8504,6 +8504,26 @@ class CortexBasicTest(s_t_utils.SynTest):
                     self.notin('Timeout waiting for pool mirror', data)
                     self.notin('Timeout waiting for query mirror', data)
 
+                    orig = s_telepath.ClientV2.proxy
+                    async def finidproxy(self, timeout=None):
+                        prox = await orig(self, timeout=timeout)
+                        await prox.fini()
+                        return prox
+
+                    with patch('synapse.telepath.ClientV2.proxy', finidproxy):
+                        with self.getLoggerStream('synapse') as stream:
+                            msgs = await alist(core00.storm('inet:asn=0'))
+                            self.len(1, [m for m in msgs if m[0] == 'node'])
+
+                    stream.seek(0)
+                    data = stream.read()
+                    self.isin('Proxy for pool mirror [01.core.synapse] was shutdown. Skipping.', data)
+
+                    msgs = await core00.stormlist('cortex.storm.pool.set --connection-timeout 1 --sync-timeout 1 aha://pool00...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('Storm pool configuration set.', msgs)
+                    await core00.stormpool.waitready(timeout=12)
+
                     core01.nexsroot.nexslog.indx = 0
 
                     with patch('synapse.cortex.MAX_NEXUS_DELTA', 1):
@@ -8516,8 +8536,7 @@ class CortexBasicTest(s_t_utils.SynTest):
 
                         stream.seek(0)
                         data = stream.read()
-                        explog = (f'Pool mirror [01.core.synapse] Nexus offset delta too large '
-                                  f'({nexsoffs} > 1), running query locally')
+                        explog = ('Pool mirror [01.core.synapse] is too far out of sync. Skipping.')
                         self.isin(explog, data)
                         self.notin('Offloading Storm query', data)
 
@@ -8575,7 +8594,8 @@ class CortexBasicTest(s_t_utils.SynTest):
 
                     stream.seek(0)
                     data = stream.read()
-                    self.isin('Timeout waiting for pool mirror, running query locally', data)
+                    self.isin('Timeout waiting for pool mirror proxy.', data)
+                    self.isin('Pool members exhausted. Running query locally.', data)
 
                     await core01.fini()
 

{synapse-2.201.0 → synapse-2.202.0}/synapse/tests/test_lib_cell.py

@@ -1817,8 +1817,16 @@ class CellTest(s_t_utils.SynTest):
 
                     with open(bkuppath3, 'wb') as bkup3:
                         async for msg in proxy.iterNewBackupArchive('bkup3', remove=True):
+                            self.true(core.backupstreaming)
                             bkup3.write(msg)
 
+                    async def streamdone():
+                        while core.backupstreaming:
+                            await asyncio.sleep(0)
+
+                    task = core.schedCoro(streamdone())
+                    await asyncio.wait_for(task, 15)
+
                     self.eq(('bkup', 'bkup2'), sorted(await proxy.getBackups()))
                     self.false(os.path.isdir(os.path.join(backdirn, 'bkup3')))
 
@@ -1830,6 +1838,9 @@ class CellTest(s_t_utils.SynTest):
                         async for msg in proxy.iterNewBackupArchive(remove=True):
                             bkup4.write(msg)
 
+                    task = core.schedCoro(streamdone())
+                    await asyncio.wait_for(task, 15)
+
                     self.eq(('bkup', 'bkup2'), sorted(await proxy.getBackups()))
 
                     # Start another backup while one is already running

{synapse-2.201.0 → synapse-2.202.0}/synapse/tests/test_lib_grammar.py

@@ -746,6 +746,8 @@ Queries = [
     '[test:str=foo :bar--=(foo, bar)]',
     '[test:str=foo :bar?++=$baz]',
     '[test:str=foo :bar?--={[it:dev:str=foo]}]',
+    '$foo=(notime,)',
+    '$foo=(nulltime,)',
 ]
 
 # Generated with print_parse_list below
@@ -1394,6 +1396,8 @@ _ParseResults = [
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [Const: bar], Const: --=, List: [Const: foo, Const: bar]]]',
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [Const: bar], Const: ?++=, VarValue: [Const: baz]]]',
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [Const: bar], Const: ?--=, SubQuery: [Query: [EditNodeAdd: [FormName: [Const: it:dev:str], Const: =, Const: foo]]]]]',
+    'Query: [SetVarOper: [Const: foo, List: [Const: notime]]]',
+    'Query: [SetVarOper: [Const: foo, List: [Const: nulltime]]]',
 ]
 
 class GrammarTest(s_t_utils.SynTest):

{synapse-2.201.0 → synapse-2.202.0}/synapse/tests/test_lib_storm.py

@@ -167,6 +167,12 @@ class StormTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('ou:org=({"name": "origname"}) [ :name=newname ]'))
             self.len(0, await core.nodes('ou:org=({"name": "origname"})'))
 
+            nodes = await core.nodes('[ it:exec:proc=(notime,) ]')
+            self.len(1, nodes)
+
+            nodes = await core.nodes('[ it:exec:proc=(nulltime,) ]')
+            self.len(1, nodes)
+
     async def test_lib_storm_jsonexpr(self):
         async with self.getTestCore() as core:
 

{synapse-2.201.0 → synapse-2.202.0}/synapse/tests/test_telepath.py

@@ -318,6 +318,10 @@ class TeleTest(s_t_utils.SynTest):
             link.onfini(evt.set)
             s_glob.sync(proxy._putPoolLink(link))
 
+            # Grab the fresh link from the pool so our original link is up next again
+            link2 = s_glob.sync(proxy.getPoolLink())
+            s_glob.sync(proxy._putPoolLink(link2))
+
             q = f'{form} | sleep 0.1'
 
             # Break from the generator right away, causing a
@@ -935,7 +939,6 @@ class TeleTest(s_t_utils.SynTest):
 
             # Validate the Proxy behavior then the client override
             prox = await s_telepath.openurl(url)  # type: Foo
-            prox._link_poolsize = 2
 
             # Start with no links
             self.len(0, prox.links)
@@ -947,53 +950,72 @@ class TeleTest(s_t_utils.SynTest):
             genr = await prox.genr()  # type: s_coro.GenrHelp
             self.eq(await genr.genr.__anext__(), 10)
 
-            # The link is being used by the genr
-            self.len(0, prox.links)
-
-            # and upon exhuastion, that link is put back
-            self.eq(await genr.list(), (20, 30))
+            # A new link is in the pool
             self.len(1, prox.links)
-            self.true(prox.links[0] is l0)
 
-            # Grab the existing link, then do two more calls
-            genr0 = await prox.genr()  # contains l0
-            genr1 = await prox.genr()
-            genr2 = await prox.genr()
-            self.len(0, prox.links)
-            # Consume two of the three generators
-            self.eq(await genr2.list(), (10, 20, 30))
-            self.len(1, prox.links)
-            self.eq(await genr1.list(), (10, 20, 30))
+            # and upon exhuastion, the first link is put back
+            self.eq(await genr.list(), (20, 30))
             self.len(2, prox.links)
-            # Exhausting the lsat generator results in his
-            # link not being placed back into the pool
-            self.eq(await genr0.list(), (10, 20, 30))
+            self.true(prox.links[1] is l0)
+
+            # Grabbing a link will still spin up another since we are below low watermark
+            genr = await prox.genr()  # type: s_coro.GenrHelp
+            self.eq(await genr.genr.__anext__(), 10)
+
             self.len(2, prox.links)
-            links = set(lnk for lnk in prox.links)
-            self.notin(l0, links)
-            # And that link l0 has been fini'd
-            self.true(l0.isfini)
+
+            self.eq(await genr.list(), (20, 30))
+            self.len(3, prox.links)
+
+            # Fill up pool above low watermark
+            genrs = [await prox.genr() for _ in range(2)]
+            [await genr.list() for genr in genrs]
+            self.len(5, prox.links)
+
+            # Grabbing a link no longer spins up a replacement
+            genr = await prox.genr()  # type: s_coro.GenrHelp
+            self.eq(await genr.genr.__anext__(), 10)
+            self.len(4, prox.links)
+
+            self.eq(await genr.list(), (20, 30))
+            self.len(5, prox.links)
 
             # Tear down a link by hand and place it back
             # into the pool - that will fail b/c the link
             # has been down down.
             l1 = await prox.getPoolLink()
-            self.len(1, prox.links)
+            self.len(4, prox.links)
             await l1.fini()
             await prox._putPoolLink(l1)
-            self.len(1, prox.links)
+            self.len(4, prox.links)
 
             # And all our links are torn down on fini
             await prox.fini()
-            self.len(1, prox.links)
-            for link in prox.links:
-                self.true(link.isfini)
+            self.len(4, prox.links)
+            for link in list(prox.links):
+                self.true(await link.waitfini(1))
+            self.len(0, prox.links)
+
+        with mock.patch('synapse.telepath.LINK_CULL_INTERVAL', 1):
+            async with self.getTestDmon() as dmon:
+                dmon.share('foo', foo)
+                url = f'tcp://127.0.0.1:{dmon.addr[1]}/foo'
+
+                prox = await s_telepath.openurl(url)
 
-            # The telepath Client passes through this value as a configuration parameter
-            conf = {'link_poolsize': 2, 'timeout': 2}
-            async with await s_telepath.Client.anit(url, conf=conf) as client:
-                await client.waitready()
-                self.true(client._t_proxy._link_poolsize, 2)
+                # Fill up pool above high watermark
+                genrs = [await prox.genr() for _ in range(13)]
+                [await genr.list() for genr in genrs]
+                self.len(13, prox.links)
+
+                # Add a fini'd proxy for coverage
+                prox2 = await s_telepath.openurl(url)
+                await prox2.fini()
+                prox2._all_proxies.add(prox2)
+
+                wait = prox.waiter(1, 'pool:link:fini')
+                self.len(1, await wait.wait(timeout=5))
+                self.len(12, prox.links)
 
     async def test_link_fini_breaking_tasks(self):
         foo = Foo()
@@ -1062,7 +1084,7 @@ class TeleTest(s_t_utils.SynTest):
 
                 self.eq(vals, (40, 50, 60))
 
-                self.eq(1, len(proxy.links))
+                self.eq(2, len(proxy.links))
                 self.eq(160, await proxy.bar(80, 80))
 
                 async def boomgenr():