synapse 2.164.0__py311-none-any.whl → 2.166.0__py311-none-any.whl

synapse/models/science.py

@@ -0,0 +1,102 @@
+import synapse.lib.module as s_module
+
+class ScienceModule(s_module.CoreModule):
+
+    def getModelDefs(self):
+        return (('sci', {
+            'types': (
+                ('sci:hypothesis:type:taxonomy', ('taxonomy', {}), {
+                    'doc': 'A taxonomy of hypothesis types.'}),
+                ('sci:hypothesis', ('guid', {}), {
+                    'doc': 'A hypothesis or theory.'}),
+
+                # TODO link experiment to eventual procedure node
+                ('sci:experiment:type:taxonomy', ('taxonomy', {}), {
+                    'doc': 'A taxonomy of experiment types.'}),
+                ('sci:experiment', ('guid', {}), {
+                    'doc': 'An instance of running an experiment.'}),
+
+                ('sci:observation', ('guid', {}), {
+                    'doc': 'An observation which may have resulted from an experiment.'}),
+
+                ('sci:evidence', ('guid', {}), {
+                    'doc': 'An assessment of how an observation supports or refutes a hypothesis.'}),
+            ),
+
+            'edges': (
+                (('sci:experiment', 'uses', None), {
+                    'doc': 'The experiment used the target nodes when it was run.'}),
+                (('sci:observation', 'has', None), {
+                    'doc': 'The observations are summarized from the target nodes.'}),
+                (('sci:evidence', 'has', None), {
+                    'doc': 'The evidence includes observations from the target nodes.'}),
+            ),
+
+            'forms': (
+                # TODO many of these forms need author/contact props
+                ('sci:hypothesis:type:taxonomy', {}, {}),
+                ('sci:hypothesis', {}, (
+
+                    ('name', ('str', {'lower': True, 'onespace': True}), {
+                        'doc': 'The name of the hypothesis.'}),
+
+                    ('type', ('sci:hypothesis:type:taxonomy', {}), {
+                        'doc': 'The type of hypothesis as a user defined taxonomy.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of the hypothesis.'}),
+                )),
+
+                # TODO eventually link to a procedure form
+                ('sci:experiment:type:taxonomy', {}, {}),
+                ('sci:experiment', {}, (
+
+                    ('name', ('str', {'lower': True, 'onespace': True}), {
+                        'doc': 'The name of the experiment.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of the experiment.'}),
+
+                    ('time', ('time', {}), {
+                        'doc': 'The time when the experiment was initiated.'}),
+
+                    ('type', ('sci:experiment:type:taxonomy', {}), {
+                        'doc': 'The type of experiment as a user defined taxonomy.'}),
+
+                    ('window', ('ival', {}), {
+                        'doc': 'The time window where the experiment was run.'}),
+
+                )),
+
+                ('sci:observation', {}, (
+
+                    ('experiment', ('sci:experiment', {}), {
+                        'doc': 'The experiment which produced the observation.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of the observation.'}),
+
+                    ('time', ('time', {}), {
+                        'doc': 'The time that the observation occurred.'}),
+                )),
+
+                ('sci:evidence', {}, (
+
+                    ('hypothesis', ('sci:experiment', {}), {
+                        'doc': 'The hypothesis which the evidence supports or refutes.'}),
+
+                    ('observation', ('sci:observation', {}), {
+                        'doc': 'The observation which supports or refutes the hypothesis.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of how the observation supports or refutes the hypothesis.'}),
+
+                    ('refutes', ('bool', {}), {
+                        'doc': 'Set to true if the evidence refutes the hypothesis or false if it supports the hypothesis.'}),
+                )),
+            ),
+        }),)

synapse/telepath.py

@@ -135,25 +135,24 @@ def mergeAhaInfo(info0, info1):
 
     return info0
 
-async def open(url, timeout=None):
+async def open(url, onlink=None):
     '''
-    Open a new telepath Client (or AHA Service Pool) based on the given URL.
-    '''
-    # backward compatible support for a list of URLs or urlinfo dicts...
-    if isinstance(url, (tuple, list)): # pragma: no cover
-        return await Client.anit(url)
-
-    urlinfo = chopurl(url)
+    Open a new telepath ClientV2 object based on the given URL.
 
-    if urlinfo.get('scheme') == 'aha':
-
-        ahaclient, ahasvc = await _getAhaSvc(urlinfo, timeout=timeout)
+    Args:
+        url (str): The URL to connect to.
+        onlink: An optional async callback function to run when connections are made.
 
-        # check if we should return a Pool rather than a Client :)
-        if ahasvc.get('services'):
-            return await Pool.anit(ahaclient, ahasvc, urlinfo)
+    Notes:
+        The onlink callback function has the call signature ``(proxy, urlinfo)``.
+        The proxy is the Telepath Proxy object.
+        The urlinfo is the parsed URL information used to create the proxy object.
+        The urlinfo structure may change between versions of Synapse.
 
-    return await Client.anit(urlinfo)
+    Returns:
+        ClientV2: A ClientV2 object.
+    '''
+    return await ClientV2.anit(url, onlink=onlink)
 
 async def _getAhaSvc(urlinfo, timeout=None):
 
@@ -832,7 +831,7 @@ class Proxy(s_base.Base):
 
                         mesg = await link.rx()
                         if mesg is None:
-                            raise s_exc.LinkShutDown(mesg=mesg)
+                            raise s_exc.LinkShutDown(mesg='Remote peer disconnected')
 
                         if mesg[0] != 't2:yield':  # pragma: no cover
                             info = 'Telepath protocol violation:  unexpected message received'
@@ -869,6 +868,8 @@ class Proxy(s_base.Base):
         if self.sess is not None:
             return await self.taskv2(todo, name=name)
 
+        s_common.deprecated('Telepath task with no session', curv='2.166.0')
+
         task = Task()
 
         mesg = ('task:init', {
@@ -980,21 +981,39 @@ class Proxy(s_base.Base):
         setattr(self, name, meth)
         return meth
 
-class Pool(s_base.Base):
+class ClientV2(s_base.Base):
     '''
     A telepath client which:
         * connects to multiple services
         * distributes API calls across them
         * receives topology updates from AHA
+
+    NOTE: This must co-exist with Client until we eliminate uses that
+          attempt to call telepath APIs directly from the Client rather
+          than awaiting a proxy()
     '''
-    async def __anit__(self, aha, ahasvc, urlinfo):
+    async def __anit__(self, urlinfo, onlink=None):
+
         await s_base.Base.__anit__(self)
+
+        # some ugly stuff in order to be backward compatible...
+        if not isinstance(urlinfo, (list, tuple)):
+            urlinfo = (urlinfo,)
+
+        urlinfo = [chopurl(u) for u in urlinfo]
+
+        self.aha = None
+
         self.clients = {}
         self.proxies = set()
 
-        self.aha = aha
-        self.ahasvc = ahasvc
-        self.urlinfo = urlinfo
+        self.poolname = None
+
+        self.onlink = onlink
+
+        self.booturls = urlinfo
+        self.bootdeque = collections.deque()
+        self.bootdeque.extend(self.booturls)
 
         self.ready = asyncio.Event()
         self.deque = collections.deque()
@@ -1003,7 +1022,6 @@ class Pool(s_base.Base):
             'svc:add': self._onPoolSvcAdd,
             'svc:del': self._onPoolSvcDel,
         }
-        self.schedCoro(self._toposync())
 
         async def fini():
             await self._shutDownPool()
@@ -1012,19 +1030,72 @@ class Pool(s_base.Base):
 
         self.onfini(fini)
 
+        self.schedCoro(self._initBootProxy())
+
+    def getNextBootUrl(self):
+        if not self.bootdeque:
+            self.bootdeque.extend(self.booturls)
+        return self.bootdeque.popleft()
+
+    async def _initBootProxy(self):
+
+        lastlog = 0.0
+        while not self.isfini:
+
+            urlinfo = self.getNextBootUrl()
+
+            try:
+
+                if urlinfo.get('scheme') == 'aha':
+
+                    self.aha, svcinfo = await _getAhaSvc(urlinfo)
+
+                    # if the service is a pool, enter pool mode and fire
+                    # the topography sync task to manage pool members.
+                    services = svcinfo.get('services')
+                    if services is not None:
+                        # we are an AHA pool!
+                        if self.poolname is None:
+                            self.poolname = svcinfo.get('name')
+                            self.schedCoro(self._toposync())
+                        return
+
+                # regular telepath client behavior
+                proxy = await openinfo(urlinfo)
+                await self._onPoolLink(proxy, urlinfo)
+
+                async def reconnect():
+                    if not self.isfini:
+                        self.schedCoro(self._initBootProxy())
+
+                proxy.onfini(reconnect)
+                return
+
+            except Exception as e:
+
+                now = time.monotonic()
+                if now > lastlog + 60.0:  # don't logspam the disconnect message more than 1/min
+                    url = s_urlhelp.sanitizeUrl(zipurl(urlinfo))
+                    logger.exception(f'telepath clientv2 ({url}) encountered an error: {e}')
+                    lastlog = now
+
+                retrysleep = float(urlinfo.get('retrysleep', 0.2))
+                await self.waitfini(timeout=retrysleep)
+
+    async def waitready(self, timeout=None):
+        await s_common.wait_for(self.ready.wait(), timeout=timeout)
+
     def size(self):
-        return len(self.clients)
+        return len(self.proxies)
 
     async def _onPoolSvcAdd(self, mesg):
         svcname = mesg[1].get('name')
-        svcinfo = mesg[1].get('svcinfo')
-        urlinfo = mergeAhaInfo(self.urlinfo, svcinfo.get('urlinfo', {}))
 
         if (oldc := self.clients.pop(svcname, None)) is not None:
             await oldc.fini()
 
-        # one-off default user to root
-        self.clients[svcname] = await Client.anit(urlinfo, onlink=self._onPoolLink)
+        urlinfo = {'scheme': 'aha', 'host': svcname, 'path': ''}
+        self.clients[svcname] = await ClientV2.anit(urlinfo, onlink=self._onPoolLink)
         await self.fire('svc:add', **mesg[1])
 
     async def _onPoolSvcDel(self, mesg):
@@ -1035,10 +1106,13 @@ class Pool(s_base.Base):
         self.deque.clear()
         await self.fire('svc:del', **mesg[1])
 
-    async def _onPoolLink(self, proxy):
+    async def _onPoolLink(self, proxy, urlinfo):
 
         async def onfini():
-            self.proxies.remove(proxy)
+            if proxy in self.proxies:
+                self.proxies.remove(proxy)
+            if proxy in self.deque:
+                self.deque.remove(proxy)
             if not len(self.proxies):
                 self.ready.clear()
 
@@ -1046,13 +1120,23 @@ class Pool(s_base.Base):
         self.proxies.add(proxy)
         self.ready.set()
 
+        if self.onlink is not None:
+            try:
+                await self.onlink(proxy, urlinfo)
+            except Exception as e:
+                logger.exception(f'onlink: {self.onlink}')
+
     async def _shutDownPool(self):
         # when we reconnect to our AHA service, we need to dump the current
         # topology state and gather it again.
-        for client in self.clients.values():
+        for client in list(self.clients.values()):
             await client.fini()
 
+        for proxy in list(self.proxies):
+            await proxy.fini()
+
         self.deque.clear()
+        self.ready.clear()
         self.clients.clear()
         self.proxies.clear()
 
@@ -1065,16 +1149,14 @@ class Pool(s_base.Base):
 
         while not self.isfini:
 
-            poolname = self.ahasvc.get('name')
-
             try:
                 ahaproxy = await self.aha.proxy()
 
                 await reset()
 
-                async for mesg in ahaproxy.iterPoolTopo(poolname):
+                async for mesg in ahaproxy.iterPoolTopo(self.poolname):
                     hand = self.mesghands.get(mesg[0])
-                    if hand is None: # pragma: no cover
+                    if hand is None:  # pragma: no cover
                         logger.warning(f'Unknown AHA pool topography message: {mesg}')
                         continue
 
@@ -1092,7 +1174,7 @@ class Pool(s_base.Base):
 
                 await self.ready.wait()
 
-                if self.isfini: # pragma: no cover
+                if self.isfini:  # pragma: no cover
                     raise s_exc.IsFini()
 
                 if not self.deque: