synapse 2.195.1__py311-none-any.whl → 2.197.0__py311-none-any.whl

synapse/lib/stormtypes.py

@@ -2381,6 +2381,50 @@ class LibAxon(Lib):
                       {'name': 'sha256', 'type': 'str', 'desc': 'The sha256 value to calculate hashes for.', },
                   ),
                   'returns': {'type': 'dict', 'desc': 'A dictionary of additional hashes.', }}},
+
+        {'name': 'read', 'desc': '''
+            Read bytes from a file stored in the Axon by its SHA256 hash.
+
+            Examples:
+                Read 100 bytes starting at offset 0::
+
+                    $byts = $lib.axon.read($sha256, size=100)
+
+                Read 50 bytes starting at offset 200::
+
+                    $byts = $lib.axon.read($sha256, offs=200, size=50)
+            ''',
+         'type': {'type': 'function', '_funcname': 'read',
+                  'args': (
+                      {'name': 'sha256', 'type': 'str', 'desc': 'The SHA256 hash of the file to read.'},
+                      {'name': 'offs', 'type': 'int', 'default': 0,
+                       'desc': 'The offset to start reading from.'},
+                      {'name': 'size', 'type': 'int', 'default': s_const.mebibyte,
+                       'desc': 'The number of bytes to read. Max is 1 MiB.'},
+                  ),
+                  'returns': {'type': 'bytes', 'desc': 'The requested bytes from the file.'}}},
+
+        {'name': 'unpack', 'desc': '''
+            Unpack bytes from a file stored in the Axon into a struct using the specified format.
+
+            Examples:
+                Unpack two 32-bit integers from the start of a file::
+
+                    $nums = $lib.axon.unpack($sha256, '<II')
+
+                Unpack a 64-bit float starting at offset 100::
+
+                    $float = $lib.axon.unpack($sha256, '<d', offs=100)
+            ''',
+         'type': {'type': 'function', '_funcname': 'unpack',
+                  'args': (
+                      {'name': 'sha256', 'type': 'str', 'desc': 'The SHA256 hash of the file to read.'},
+                      {'name': 'fmt', 'type': 'str', 'desc': 'The struct format string.'},
+                      {'name': 'offs', 'type': 'int', 'default': 0,
+                       'desc': 'The offset to start reading from.'},
+                  ),
+                  'returns': {'type': 'list', 'desc': 'The unpacked values as a tuple.'}}},
+
         {'name': 'upload', 'desc': '''
             Upload a stream of bytes to the Axon as a file.
 
@@ -2426,6 +2470,8 @@ class LibAxon(Lib):
             'size': self.size,
             'upload': self.upload,
             'hashset': self.hashset,
+            'read': self.read,
+            'unpack': self.unpack,
         }
 
     @stormfunc(readonly=True)
@@ -2712,6 +2758,48 @@ class LibAxon(Lib):
         await self.runt.snap.core.getAxon()
         return await self.runt.snap.core.axon.hashset(s_common.uhex(sha256))
 
+    @stormfunc(readonly=True)
+    async def read(self, sha256, offs=0, size=s_const.mebibyte):
+        '''
+        Read bytes from a file in the Axon.
+        '''
+        sha256 = await tostr(sha256)
+        size = await toint(size)
+        offs = await toint(offs)
+
+        if size > s_const.mebibyte:
+            mesg = f'Size must be between 1 and {s_const.mebibyte} bytes'
+            raise s_exc.BadArg(mesg=mesg)
+
+        if not self.runt.allowed(('axon', 'get')):
+            self.runt.confirm(('storm', 'lib', 'axon', 'get'))
+
+        await self.runt.snap.core.getAxon()
+
+        byts = b''
+        async for chunk in self.runt.snap.core.axon.get(s_common.uhex(sha256), offs=offs, size=size):
+            byts += chunk
+        return byts
+
+    @stormfunc(readonly=True)
+    async def unpack(self, sha256, fmt, offs=0):
+        '''
+        Unpack bytes from a file in the Axon using struct.
+        '''
+        if self.runt.snap.core.axoninfo.get('features', {}).get('unpack', 0) < 1:
+            mesg = 'The connected Axon does not support the the unpack API. Please update your Axon.'
+            raise s_exc.FeatureNotSupported(mesg=mesg)
+
+        sha256 = await tostr(sha256)
+        fmt = await tostr(fmt)
+        offs = await toint(offs)
+
+        if not self.runt.allowed(('axon', 'get')):
+            self.runt.confirm(('storm', 'lib', 'axon', 'get'))
+
+        await self.runt.snap.core.getAxon()
+        return await self.runt.snap.core.axon.unpack(s_common.uhex(sha256), fmt, offs)
+
 @registry.registerLib
 class LibBytes(Lib):
     '''
@@ -6751,7 +6839,8 @@ class Layer(Prim):
     Implements the Storm api for a layer instance.
     '''
     _storm_locals = (
-        {'name': 'iden', 'desc': 'The iden of the Layer.', 'type': 'str', },
+        {'name': 'iden', 'desc': 'The iden of the Layer.', 'type': 'str'},
+        {'name': 'name', 'desc': 'The name of the Layer.', 'type': 'str'},
         {'name': 'set', 'desc': 'Set an arbitrary value in the Layer definition.',
          'type': {'type': 'function', '_funcname': '_methLayerSet',
                   'args': (
@@ -6999,6 +7088,22 @@ class Layer(Prim):
                   'returns': {'name': 'Yields', 'type': 'node',
                               'desc': 'Yields nodes.', }}},
 
+        {'name': 'liftByNodeData', 'desc': '''
+            Lift and yield nodes with the given node data key set within the layer.
+
+            Example:
+                Yield all nodes with the data key zootsuit set in the top layer::
+
+                    yield $lib.layer.get().liftByNodeData(zootsuit)
+
+            ''',
+         'type': {'type': 'function', '_funcname': 'liftByNodeData',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The node data name to lift by.'},
+                  ),
+                  'returns': {'name': 'Yields', 'type': 'node',
+                              'desc': 'Yields nodes.', }}},
+
         {'name': 'getEdges', 'desc': '''
             Yield (n1iden, verb, n2iden) tuples for any light edges in the layer.
 
@@ -7090,6 +7195,7 @@ class Layer(Prim):
 
         self.locls.update(self.getObjLocals())
         self.locls['iden'] = self.valu.get('iden')
+        self.locls['name'] = self.valu.get('name')
 
     def __hash__(self):
         return hash((self._storm_typename, self.locls['iden']))
@@ -7110,6 +7216,7 @@ class Layer(Prim):
             'getEdges': self.getEdges,
             'liftByTag': self.liftByTag,
             'liftByProp': self.liftByProp,
+            'liftByNodeData': self.liftByNodeData,
             'getTagCount': self._methGetTagCount,
             'getPropCount': self._methGetPropCount,
             'getPropValues': self._methGetPropValues,
@@ -7177,6 +7284,19 @@ class Layer(Prim):
         async for _, buid, sode in layr.liftByPropValu(liftform, liftprop, cmprvals):
             yield await self.runt.snap._joinStorNode(buid, {iden: sode})
 
+    @stormfunc(readonly=True)
+    async def liftByNodeData(self, name):
+
+        name = await tostr(name)
+
+        iden = self.valu.get('iden')
+        layr = self.runt.snap.core.getLayer(iden)
+
+        await self.runt.reqUserCanReadLayer(iden)
+
+        async for _, buid, sode in layr.liftByDataName(name):
+            yield await self.runt.snap._joinStorNode(buid, {iden: sode})
+
     @stormfunc(readonly=True)
     async def getMirrorStatus(self):
         iden = self.valu.get('iden')

synapse/lib/task.py

@@ -1,4 +1,3 @@
-import copy
 import asyncio
 import logging
 
@@ -6,6 +5,7 @@ import synapse.exc as s_exc
 import synapse.common as s_common
 
 import synapse.lib.base as s_base
+import synapse.lib.msgpack as s_msgpack
 
 logger = logging.getLogger(__name__)
 
@@ -104,7 +104,7 @@ class Task(s_base.Base):
         pask = {
             'iden': self.iden,
             'name': self.name,
-            'info': copy.deepcopy(self.info),
+            'info': s_msgpack.deepcopy(self.info),
             'tick': self.tick,
             'user': 'root',
             'kids': {i: k.pack() for i, k in self.kids.items()},
@@ -115,6 +115,17 @@ class Task(s_base.Base):
 
         return pask
 
+    def packv2(self):
+        return {
+            'iden': self.iden,
+            'name': self.name,
+            'info': s_msgpack.deepcopy(self.info),
+            'tick': self.tick,
+            'user': self.user.iden,
+            'username': self.user.name,
+            'kids': {i: k.packv2() for i, k in self.kids.items()},
+        }
+
 def loop():
     try:
         return asyncio.get_running_loop()

synapse/lib/urlhelp.py

@@ -13,7 +13,7 @@ def chopurl(url):
     '''
     ret = {}
     if url.find('://') == -1:
-        raise s_exc.BadUrl(':// not found in [{}]!'.format(url))
+        raise s_exc.BadUrl(mesg=':// not found in [{}]!'.format(url))
 
     scheme, remain = url.split('://', 1)
     ret['scheme'] = scheme.lower()

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, 195, 1)
+version = (2, 197, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '83cc00aa05086cbc4dfec2f820db8f392c76a012'
+commit = 'c8c758131cae47ef21e23ac8242012459ebfce9d'

synapse/models/base.py

@@ -193,6 +193,9 @@ class BaseModule(s_module.CoreModule):
                     ('url', ('inet:url', {}), {
                         'doc': 'A URL which documents the meta source.'}),
 
+                    ('ingest:cursor', ('str', {}), {
+                        'doc': 'Used by ingest logic to capture the current ingest cursor within a feed.'}),
+
                     ('ingest:latest', ('time', {}), {
                         'doc': 'Used by ingest logic to capture the last time a feed ingest ran.'}),
 

synapse/models/doc.py

@@ -77,6 +77,30 @@ class DocModule(s_module.CoreModule):
                         'documents': 'standards',
                         'type': 'doc:standard:type:taxonomy'},
                     'doc': 'A group of requirements which define how to implement a policy or goal.'}),
+
+                ('doc:requirement:type:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy of requirement types.'}),
+
+                ('doc:requirement', ('guid', {}), {
+                    'interfaces': ('doc:document',),
+                    'template': {
+                        'document': 'requirement',
+                        'documents': 'requirements',
+                        'type': 'doc:requirement:type:taxonomy'},
+                    'doc': 'A single requirement, often defined by a standard.'}),
+
+                ('doc:resume:type:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy of resume types.'}),
+
+                ('doc:resume', ('guid', {}), {
+                    'interfaces': ('doc:document',),
+                    'template': {
+                        'document': 'resume',
+                        'documents': 'resumes',
+                        'type': 'doc:resume:type:taxonomy'},
+                    'doc': 'A CV/resume document.'}),
             ),
             'forms': (
 
@@ -88,6 +112,44 @@ class DocModule(s_module.CoreModule):
                     ('policy', ('doc:policy', {}), {
                         'doc': 'The policy which was used to derive the standard.'}),
                 )),
+
+                ('doc:requirement:type:taxonomy', {}, ()),
+                ('doc:requirement', {}, (
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of the requirement definition.'}),
+
+                    ('optional', ('bool', {}), {
+                        'doc': 'Set to true if the requirement is optional as defined by the standard.'}),
+
+                    ('priority', ('meta:priority', {}), {
+                        'doc': 'The priority of the requirement as defined by the standard.'}),
+
+                    ('standard', ('doc:standard', {}), {
+                        'doc': 'The standard which defined the requirement.'}),
+                )),
+
+                ('doc:resume:type:taxonomy', {}, ()),
+                ('doc:resume', {}, (
+
+                    ('contact', ('ps:contact', {}), {
+                        'doc': 'Contact information for subject of the resume.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'The summary of qualifications from the resume.'}),
+
+                    ('workhist', ('array', {'type': 'ps:workhist', 'sorted': True, 'uniq': True}), {
+                        'doc': 'Work history described in the resume.'}),
+
+                    ('education', ('array', {'type': 'ps:education', 'sorted': True, 'uniq': True}), {
+                        'doc': 'Education experience described in the resume.'}),
+
+                    ('achievements', ('array', {'type': 'ps:achievement', 'sorted': True, 'uniq': True}), {
+                        'doc': 'Achievements described in the resume.'}),
+
+                )),
             ),
             'edges': (),
         }),)

synapse/models/infotech.py

@@ -1417,6 +1417,36 @@ class ItModule(s_module.CoreModule):
                         'deprecated': True,
                         'doc': 'Deprecated. Please use risk:vuln:cve:references.'}),
 
+                    ('nist:nvd:source', ('ou:name', {}), {
+                        'doc': 'The name of the organization which reported the vulnerability to NIST.'}),
+
+                    ('nist:nvd:published', ('time', {}), {
+                        'doc': 'The date the vulnerability was first published in the NVD.'}),
+
+                    ('nist:nvd:modified', ('time', {"ismax": True}), {
+                        'doc': 'The date the vulnerability was last modified in the NVD.'}),
+
+                    ('cisa:kev:name', ('str', {}), {
+                        'doc': 'The name of the vulnerability according to the CISA KEV database.'}),
+
+                    ('cisa:kev:desc', ('str', {}), {
+                        'doc': 'The description of the vulnerability according to the CISA KEV database.'}),
+
+                    ('cisa:kev:action', ('str', {}), {
+                        'doc': 'The action to mitigate the vulnerability according to the CISA KEV database.'}),
+
+                    ('cisa:kev:vendor', ('ou:name', {}), {
+                        'doc': 'The vendor name listed in the CISA KEV database.'}),
+
+                    ('cisa:kev:product', ('it:prod:softname', {}), {
+                        'doc': 'The product name listed in the CISA KEV database.'}),
+
+                    ('cisa:kev:added', ('time', {}), {
+                        'doc': 'The date the vulnerability was added to the CISA KEV database.'}),
+
+                    ('cisa:kev:duedate', ('time', {}), {
+                        'doc': 'The date the action is due according to the CISA KEV database.'}),
+
                 )),
                 ('it:sec:cpe', {}, (
                     ('v2_2', ('it:sec:cpe:v2_2', {}), {
@@ -2248,29 +2278,34 @@ class ItModule(s_module.CoreModule):
                         'doc': 'Software architecture.',
                     }),
                     ('released', ('time', {}), {
-                        'doc': 'Timestamp for when this version of the software was released.',
-                    }),
+                        'doc': 'Timestamp for when this version of the software was released.'}),
+
                     ('semver', ('it:semver', {}), {
-                        'doc': 'System normalized semantic version number.',
-                    }),
+                        'doc': 'System normalized semantic version number.'}),
+
                     ('semver:major', ('int', {}), {
-                        'doc': 'Version major number.',
-                    }),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use semver range queries.'}),
+
                     ('semver:minor', ('int', {}), {
-                        'doc': 'Version minor number.',
-                    }),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use semver range queries.'}),
+
                     ('semver:patch', ('int', {}), {
-                        'doc': 'Version patch number.',
-                    }),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use semver range queries.'}),
+
                     ('semver:pre', ('str', {}), {
-                        'doc': 'Semver prerelease string.',
-                    }),
+                        'deprecated': True,
+                        'doc': 'Deprecated.'}),
+
                     ('semver:build', ('str', {}), {
-                        'doc': 'Semver build string.',
-                    }),
+                        'deprecated': True,
+                        'doc': 'Deprecated.'}),
+
                     ('url', ('inet:url', {}), {
-                        'doc': 'URL where a specific version of the software is available from.',
-                    }),
+                        'doc': 'URL where a specific version of the software is available from.'}),
+
                 )),
 
                 ('it:prod:softlib', {}, (
@@ -2347,6 +2382,10 @@ class ItModule(s_module.CoreModule):
                     ('signame', ('it:av:signame', {}), {
                         'doc': 'The name of the signature returned by the scanner.'}),
 
+                    ('categories', ('array', {'sorted': True, 'uniq': True,
+                            'type': 'str', 'typeopts': {'lower': True, 'onespace': True}}), {
+                        'doc': 'A list of categories for the result returned by the scanner.'}),
+
                     ('target:file', ('file:bytes', {}), {
                         'doc': 'The file that was scanned to produce the result.'}),
 

synapse/models/orgs.py

@@ -93,9 +93,10 @@ class OuModule(s_module.CoreModule):
                 ('ou:industryname', ('str', {'lower': True, 'onespace': True}), {
                     'doc': 'The name of an industry.',
                 }),
-                ('ou:alias', ('str', {'lower': True, 'regex': r'^[0-9a-z_]+$'}), {
-                    'doc': 'An alias for the org GUID.',
+                ('ou:alias', ('str', {'lower': True, 'regex': r'^[\w0-9_]+$'}), {
+                    'deprecated': True,
                     'ex': 'vertexproject',
+                    'doc': 'Deprecated. Please use ou:name.',
                 }),
                 ('ou:hasalias', ('comp', {'fields': (('org', 'ou:org'), ('alias', 'ou:alias'))}), {
                     'deprecated': True,
@@ -762,7 +763,8 @@ class OuModule(s_module.CoreModule):
                        'doc': 'A list of alternate names for the organization.',
                     }),
                     ('alias', ('ou:alias', {}), {
-                        'doc': 'The default alias for an organization.'
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use ou:org:names.',
                     }),
                     ('phone', ('tel:phone', {}), {
                         'doc': 'The primary phone number for the organization.',
@@ -1346,30 +1348,34 @@ class OuModule(s_module.CoreModule):
                     }),
                 )),
                 ('ou:contest:result', {}, (
+
                     ('contest', ('ou:contest', {}), {
                         'ro': True,
-                        'doc': 'The contest.',
-                    }),
+                        'doc': 'The contest that the participant took part in.'}),
+
                     ('participant', ('ps:contact', {}), {
                         'ro': True,
-                        'doc': 'The participant',
-                    }),
+                        'doc': 'The participant in the contest.'}),
+
                     ('rank', ('int', {}), {
-                        'doc': 'The rank order of the participant.',
-                    }),
+                        'doc': "The participant's rank order in the contest."}),
+
                     ('score', ('int', {}), {
-                        'doc': 'The score of the participant.',
-                    }),
+                        'doc': "The participant's final score in the contest."}),
+
+                    ('period', ('ival', {}), {
+                        'doc': 'The period of time when the participant competed in the contest.'}),
+
                     ('url', ('inet:url', {}), {
-                        'doc': 'The contest result website URL.',
-                    }),
+                        'doc': 'The contest result website URL.'}),
+
                 )),
                 ('ou:enacted:status:taxonomy', {}, ()),
                 ('ou:enacted', {}, (
                     ('org', ('ou:org', {}), {
                         'doc': 'The organization which is enacting the document.'}),
 
-                    ('doc', ('ndef', {'forms': ('doc:policy', 'doc:standard')}), {
+                    ('doc', ('ndef', {'forms': ('doc:policy', 'doc:standard', 'doc:requirement')}), {
                         'doc': 'The document enacted by the organization.'}),
 
                     ('scope', ('ndef', {}), {

synapse/models/risk.py

@@ -492,6 +492,9 @@ class RiskModule(s_module.CoreModule):
                     ('id', ('str', {'strip': True}), {
                         'doc': 'An identifier for the vulnerability.'}),
 
+                    ('tag', ('syn:tag', {}), {
+                        'doc': 'A tag used to annotate the presence or use of the vulnerability.'}),
+
                     ('cve', ('it:sec:cve', {}), {
                         'doc': 'The CVE ID of the vulnerability.'}),
 
@@ -506,34 +509,44 @@ class RiskModule(s_module.CoreModule):
                         'doc': 'An array of documentation URLs provided by the CVE database.'}),
 
                     ('nist:nvd:source', ('ou:name', {}), {
-                        'doc': 'The name of the organization which reported the vulnerability to NIST.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:nist:nvd:source.'}),
 
                     ('nist:nvd:published', ('time', {}), {
-                        'doc': 'The date the vulnerability was first published in the NVD.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:nist:nvd:published.'}),
 
                     ('nist:nvd:modified', ('time', {"ismax": True}), {
-                        'doc': 'The date the vulnerability was last modified in the NVD.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:nist:nvd:modified.'}),
 
                     ('cisa:kev:name', ('str', {}), {
-                        'doc': 'The name of the vulnerability according to the CISA KEV database.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:cisa:kev:name.'}),
 
                     ('cisa:kev:desc', ('str', {}), {
-                        'doc': 'The description of the vulnerability according to the CISA KEV database.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:cisa:kev:desc.'}),
 
                     ('cisa:kev:action', ('str', {}), {
-                        'doc': 'The action to mitigate the vulnerability according to the CISA KEV database.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:cisa:kev:action.'}),
 
                     ('cisa:kev:vendor', ('ou:name', {}), {
-                        'doc': 'The vendor name listed in the CISA KEV database.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:cisa:kev:vendor.'}),
 
                     ('cisa:kev:product', ('it:prod:softname', {}), {
-                        'doc': 'The product name listed in the CISA KEV database.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:cisa:kev:product.'}),
 
                     ('cisa:kev:added', ('time', {}), {
-                        'doc': 'The date the vulnerability was added to the CISA KEV database.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:cisa:kev:added.'}),
 
                     ('cisa:kev:duedate', ('time', {}), {
-                        'doc': 'The date the action is due according to the CISA KEV database.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use it:sec:cve:cisa:kev:duedate.'}),
 
                     ('cvss:v2', ('cvss:v2', {}), {
                         'doc': 'The CVSS v2 vector for the vulnerability.'}),

synapse/models/transport.py

@@ -454,21 +454,26 @@ class TransportModule(s_module.CoreModule):
                     ('type', ('transport:sea:vessel:type:taxonomy', {}), {
                         'doc': 'The type of vessel.'}),
 
-                    # TODO: convert this to an entity:name
-                    ('name', ('str', {'lower': True, 'onespace': True}), {
-                        'doc': 'The name of the vessel'}),
+                    ('name', ('entity:name', {}), {
+                        'doc': 'The name of the vessel.'}),
+
                     ('length', ('geo:dist', {}), {
                         'deprecated': True,
                         'doc': 'Deprecated. Please use :phys:length.'}),
+
                     ('beam', ('geo:dist', {}), {
                         'doc': 'The official overall vessel beam'}),
+
                     ('flag', ('iso:3166:cc', {}), {
                         'doc': 'The country the vessel is flagged to.'}),
+
                     ('mmsi', ('transport:sea:mmsi', {}), {
                         'doc': 'The Maritime Mobile Service Identifier assigned to the vessel.'}),
+
                     ('make', ('str', {'lower': True, 'strip': True}), {
                         'deprecated': True,
                         'doc': 'Deprecated. Please use :manufacturer:name.'}),
+
                     ('operator', ('ps:contact', {}), {
                         'doc': 'The contact information of the operator.'}),
                     # TODO tonnage / gross tonnage?

synapse/telepath.py

@@ -321,6 +321,9 @@ class Aware:
         '''
         return self
 
+    async def getTeleFeats(self):
+        return {}
+
     def onTeleShare(self, dmon, name):
         pass
 
@@ -599,6 +602,8 @@ class Proxy(s_base.Base):
         self.shares = {}
 
         self._ahainfo = {}
+        self._features = {}
+
         self.sharinfo = {}
         self.methinfo = {}
 
@@ -634,6 +639,12 @@ class Proxy(s_base.Base):
         self.onfini(fini)
         self.link.onfini(self.fini)
 
+    def _hasTeleFeat(self, name, vers=1):
+        return self._features.get(name, 0) >= vers
+
+    def _hasTeleMeth(self, name):
+        return self.methinfo.get(name) is not None
+
     def _getSynVers(self):
         '''
         Helper method to retrieve the remote Synapse version from Proxy.
@@ -906,6 +917,7 @@ class Proxy(s_base.Base):
 
         self.sess = self.synack[1].get('sess')
         self._ahainfo = self.synack[1].get('ahainfo', {})
+        self._features = self.synack[1].get('features', {})
         self.sharinfo = self.synack[1].get('sharinfo', {})
         self.methinfo = self.sharinfo.get('meths', {})