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

synapse/lib/storm.py

@@ -14,6 +14,7 @@ import synapse.datamodel as s_datamodel
 import synapse.lib.ast as s_ast
 import synapse.lib.base as s_base
 import synapse.lib.chop as s_chop
+import synapse.lib.coro as s_coro
 import synapse.lib.node as s_node
 import synapse.lib.snap as s_snap
 import synapse.lib.time as s_time
@@ -1873,6 +1874,14 @@ class Runtime(s_base.Base):
                     valu.incref()
             self.vars.update(varz)
 
+        self._initRuntVars(query)
+
+        self.proxies = {}
+
+        self.onfini(self._onRuntFini)
+
+    def _initRuntVars(self, query):
+
         # declare path builtins as non-runtsafe
         self.runtvars = {
             'node': False,
@@ -1881,17 +1890,14 @@ class Runtime(s_base.Base):
 
         # inherit runtsafe vars from our root
         if self.root is not None:
-            self.runtvars.update(root.runtvars)
+            self.runtvars.update(self.root.runtvars)
             self.runtvars.update({k: True for k in self.root.getScopeVars().keys()})
 
         # all vars/ctors are de-facto runtsafe
         self.runtvars.update({k: True for k in self.vars.keys()})
         self.runtvars.update({k: True for k in self.ctors.keys()})
 
-        self.proxies = {}
-
         self._loadRuntVars(query)
-        self.onfini(self._onRuntFini)
 
     def getScopeVars(self):
         '''
@@ -3491,13 +3497,18 @@ class DiffCmd(Cmd):
         // Lift the nodes with the tag #cno.mal.redtree added in the top layer.
 
         diff --tag cno.mal.redtree
+
+        // Lift nodes by multiple tags (results are uniqued)
+
+        diff --tag cno.mal.redtree rep.vt
     '''
     name = 'diff'
     readonly = True
 
     def getArgParser(self):
         pars = Cmd.getArgParser(self)
-        pars.add_argument('--tag', default=None, help='Lift only nodes with the given tag in the top layer.')
+        pars.add_argument('--tag', default=None, nargs='*',
+                          help='Lift only nodes with the given tag (or tags) in the top layer.')
         pars.add_argument('--prop', default=None, help='Lift nodes with changes to the given property the top layer.')
         return pars
 
@@ -3516,10 +3527,11 @@ class DiffCmd(Cmd):
 
         if self.opts.tag:
 
-            tagname = await s_stormtypes.tostr(self.opts.tag)
+            tagnames = [await s_stormtypes.tostr(tag) for tag in self.opts.tag]
 
             layr = runt.snap.view.layers[0]
-            async for _, buid, sode in layr.liftByTag(tagname):
+
+            async for _, buid, sode in layr.liftByTags(tagnames):
                 node = await self.runt.snap._joinStorNode(buid, {layr.iden: sode})
                 if node is not None:
                     yield node, runt.initPath(node)
@@ -3765,73 +3777,76 @@ class MergeCmd(Cmd):
     def _getPropFilter(self):
         if self.opts.include_props:
 
+            _include_props = set(self.opts.include_props)
+
             def propfilter(prop):
-                if prop in self.opts.include_props:
-                    return False
-                return True
+                return prop not in _include_props
 
             return propfilter
 
         if self.opts.exclude_props:
 
+            _exclude_props = set(self.opts.exclude_props)
+
             def propfilter(prop):
-                if prop in self.opts.exclude_props:
-                    return True
-                return False
+                return prop in _exclude_props
 
             return propfilter
 
         return None
 
-    async def _checkNodePerms(self, node, sode, runt):
+    async def _checkNodePerms(self, node, sode, runt, allows):
 
         layr0 = runt.snap.view.layers[0].iden
         layr1 = runt.snap.view.layers[1].iden
 
-        if sode.get('valu') is not None:
+        if not allows['forms'] and sode.get('valu') is not None:
             runt.confirm(('node', 'del', node.form.name), gateiden=layr0)
             runt.confirm(('node', 'add', node.form.name), gateiden=layr1)
 
-        for name, (valu, stortype) in sode.get('props', {}).items():
-            prop = node.form.prop(name)
-            runt.confirmPropDel(prop, layriden=layr0)
-            runt.confirmPropSet(prop, layriden=layr1)
+        if not allows['props']:
+            for name in sode.get('props', {}).keys():
+                prop = node.form.prop(name)
+                runt.confirmPropDel(prop, layriden=layr0)
+                runt.confirmPropSet(prop, layriden=layr1)
+
+        if not allows['tags']:
+
+            tags = []
+            tagadds = []
+            for tag, valu in sode.get('tags', {}).items():
+                if valu != (None, None):
+                    tagadds.append(tag)
+                    tagperm = tuple(tag.split('.'))
+                    runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
+                    runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
+                else:
+                    tags.append((len(tag), tag))
+
+            for _, tag in sorted(tags, reverse=True):
+                look = tag + '.'
+                if any([tagadd.startswith(look) for tagadd in tagadds]):
+                    continue
 
-        tags = []
-        tagadds = []
-        for tag, valu in sode.get('tags', {}).items():
-            if valu != (None, None):
                 tagadds.append(tag)
                 tagperm = tuple(tag.split('.'))
                 runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
                 runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
-            else:
-                tags.append((len(tag), tag))
 
-        for _, tag in sorted(tags, reverse=True):
-            look = tag + '.'
-            if any([tagadd.startswith(look) for tagadd in tagadds]):
-                continue
-
-            tagadds.append(tag)
-            tagperm = tuple(tag.split('.'))
-            runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
-            runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
-
-        for tag, tagdict in sode.get('tagprops', {}).items():
-            for prop, (valu, stortype) in tagdict.items():
+            for tag in sode.get('tagprops', {}).keys():
                 tagperm = tuple(tag.split('.'))
                 runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
                 runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
 
-        async for name in runt.snap.view.layers[0].iterNodeDataKeys(node.buid):
-            runt.confirm(('node', 'data', 'pop', name), gateiden=layr0)
-            runt.confirm(('node', 'data', 'set', name), gateiden=layr1)
+        if not allows['ndata']:
+            async for name in runt.snap.view.layers[0].iterNodeDataKeys(node.buid):
+                runt.confirm(('node', 'data', 'pop', name), gateiden=layr0)
+                runt.confirm(('node', 'data', 'set', name), gateiden=layr1)
 
-        async for edge in runt.snap.view.layers[0].iterNodeEdgesN1(node.buid):
-            verb = edge[0]
-            runt.confirm(('node', 'edge', 'del', verb), gateiden=layr0)
-            runt.confirm(('node', 'edge', 'add', verb), gateiden=layr1)
+        if not allows['edges']:
+            async for verb in runt.snap.view.layers[0].iterNodeEdgeVerbsN1(node.buid):
+                runt.confirm(('node', 'edge', 'del', verb), gateiden=layr0)
+                runt.confirm(('node', 'edge', 'add', verb), gateiden=layr1)
 
     async def execStormCmd(self, runt, genr):
 
@@ -3841,12 +3856,31 @@ class MergeCmd(Cmd):
 
         notags = self.opts.no_tags
         onlytags = self.opts.only_tags
+        doapply = self.opts.apply
 
         tagfilter = self._getTagFilter()
         propfilter = self._getPropFilter()
 
-        layr0 = runt.snap.view.layers[0].iden
-        layr1 = runt.snap.view.layers[1].iden
+        layr0 = runt.snap.view.layers[0]
+        layr1 = runt.snap.view.layers[1]
+
+        doperms = doapply and not (runt.isAdmin(gateiden=layr0.iden) and runt.isAdmin(gateiden=layr1.iden))
+
+        if doperms:
+            allows = {
+                'forms': runt.user.allowed(('node', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'add'), gateiden=layr1.iden, deepdeny=True),
+                'props': runt.user.allowed(('node', 'prop', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'prop', 'set'), gateiden=layr1.iden, deepdeny=True),
+                'tags': runt.user.allowed(('node', 'tag', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                        runt.user.allowed(('node', 'tag', 'add'), gateiden=layr1.iden, deepdeny=True),
+                'ndata': runt.user.allowed(('node', 'data', 'pop'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'data', 'set'), gateiden=layr1.iden, deepdeny=True),
+                'edges': runt.user.allowed(('node', 'edge', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'edge', 'add'), gateiden=layr1.iden, deepdeny=True),
+            }
+
+            doperms = not all(allows.values())
 
         if self.opts.diff:
 
@@ -3854,7 +3888,7 @@ class MergeCmd(Cmd):
                 yield node, path
 
             async def diffgenr():
-                async for buid, sode in runt.snap.view.layers[0].getStorNodes():
+                async for buid, sode in layr0.getStorNodes():
                     node = await runt.snap.getNodeByBuid(buid)
                     if node is not None:
                         yield node, runt.initPath(node)
@@ -3873,33 +3907,19 @@ class MergeCmd(Cmd):
                 sodes = await node.getStorNodes()
                 sode = sodes[0]
 
-                if self.opts.apply:
+                if doapply:
                     editor = s_snap.SnapEditor(snap)
 
                 subs = []
 
-                async def sync():
-
-                    if not self.opts.apply:
-                        subs.clear()
-                        return
-
-                    addedits = editor.getNodeEdits()
-                    if addedits:
-                        await runt.snap.view.parent.storNodeEdits(addedits, meta=meta)
-
-                    if subs:
-                        subedits = [(node.buid, node.form.name, subs)]
-                        await runt.snap.view.storNodeEdits(subedits, meta=meta)
-                        subs.clear()
-
                 # check all node perms first
-                if self.opts.apply:
-                    await self._checkNodePerms(node, sode, runt)
+                if doperms:
+                    await self._checkNodePerms(node, sode, runt, allows)
 
                 form = node.form.name
                 if form == 'syn:tag':
                     if notags:
+                        await asyncio.sleep(0)
                         continue
                 else:
                     # avoid merging a tag if the node won't exist below us
@@ -3908,6 +3928,7 @@ class MergeCmd(Cmd):
                             if undr.get('valu') is not None:
                                 break
                         else:
+                            await asyncio.sleep(0)
                             continue
 
                 protonode = None
@@ -3916,23 +3937,24 @@ class MergeCmd(Cmd):
                     valu = sode.get('valu')
                     if valu is not None:
 
-                        if tagfilter and form == 'syn:tag' and tagfilter(valu[0]):
+                        if tagfilter is not None and form == 'syn:tag' and tagfilter(valu[0]):
+                            await asyncio.sleep(0)
                             continue
 
-                        if not self.opts.apply:
+                        if not doapply:
                             valurepr = node.form.type.repr(valu[0])
                             await runt.printf(f'{nodeiden} {form} = {valurepr}')
                         else:
                             delnode = True
                             protonode = await editor.addNode(form, valu[0])
 
-                    elif self.opts.apply:
+                    elif doapply:
                         protonode = await editor.addNode(form, node.ndef[1], norminfo={})
 
                     for name, (valu, stortype) in sode.get('props', {}).items():
 
                         prop = node.form.prop(name)
-                        if propfilter:
+                        if propfilter is not None:
                             if name[0] == '.':
                                 if propfilter(name):
                                     continue
@@ -3942,7 +3964,7 @@ class MergeCmd(Cmd):
 
                         if prop.info.get('ro'):
                             if name == '.created':
-                                if self.opts.apply:
+                                if doapply:
                                     protonode.props['.created'] = valu
                                     subs.append((s_layer.EDIT_PROP_DEL, (name, valu, stortype), ()))
                                 continue
@@ -3952,8 +3974,8 @@ class MergeCmd(Cmd):
                                 props = undr.get('props')
                                 if props is not None:
                                     curv = props.get(name)
-                                    if curv is not None and curv[0] != valu:
-                                        isset = True
+                                    if curv is not None:
+                                        isset = curv[0] != valu
                                         break
 
                             if isset:
@@ -3963,24 +3985,23 @@ class MergeCmd(Cmd):
                                 await runt.snap.warn(mesg)
                                 continue
 
-                        if not self.opts.apply:
+                        if not doapply:
                             valurepr = prop.type.repr(valu)
                             await runt.printf(f'{nodeiden} {form}:{name} = {valurepr}')
                         else:
                             await protonode.set(name, valu)
                             subs.append((s_layer.EDIT_PROP_DEL, (name, valu, stortype), ()))
 
-                if self.opts.apply and protonode is None:
+                if doapply and protonode is None:
                     protonode = await editor.addNode(form, node.ndef[1], norminfo={})
 
                 if not notags:
                     for tag, valu in sode.get('tags', {}).items():
 
-                        if tagfilter and tagfilter(tag):
+                        if tagfilter is not None and tagfilter(tag):
                             continue
 
-                        tagperm = tuple(tag.split('.'))
-                        if not self.opts.apply:
+                        if not doapply:
                             valurepr = ''
                             if valu != (None, None):
                                 tagrepr = runt.model.type('ival').repr(valu)
@@ -3992,12 +4013,11 @@ class MergeCmd(Cmd):
 
                     for tag, tagdict in sode.get('tagprops', {}).items():
 
-                        if tagfilter and tagfilter(tag):
+                        if tagfilter is not None and tagfilter(tag):
                             continue
 
                         for prop, (valu, stortype) in tagdict.items():
-                            tagperm = tuple(tag.split('.'))
-                            if not self.opts.apply:
+                            if not doapply:
                                 valurepr = repr(valu)
                                 await runt.printf(f'{nodeiden} {form}#{tag}:{prop} = {valurepr}')
                             else:
@@ -4006,31 +4026,33 @@ class MergeCmd(Cmd):
 
                 if not onlytags or form == 'syn:tag':
 
-                    layr = runt.snap.view.layers[0]
-                    async for name, valu in layr.iterNodeData(node.buid):
-                        if not self.opts.apply:
+                    async for name, valu in s_coro.pause(layr0.iterNodeData(node.buid)):
+                        if not doapply:
                             valurepr = repr(valu)
                             await runt.printf(f'{nodeiden} {form} DATA {name} = {valurepr}')
                         else:
                             await protonode.setData(name, valu)
                             subs.append((s_layer.EDIT_NODEDATA_DEL, (name, valu), ()))
-                            if len(subs) >= 1000:
-                                await asyncio.sleep(0)
 
-                    async for edge in layr.iterNodeEdgesN1(node.buid):
+                    async for edge in s_coro.pause(layr0.iterNodeEdgesN1(node.buid)):
                         name, dest = edge
-                        if not self.opts.apply:
+                        if not doapply:
                             await runt.printf(f'{nodeiden} {form} +({name})> {dest}')
                         else:
                             await protonode.addEdge(name, dest)
                             subs.append((s_layer.EDIT_EDGE_DEL, edge, ()))
-                            if len(subs) >= 1000:
-                                await asyncio.sleep(0)
 
                 if delnode:
                     subs.append((s_layer.EDIT_NODE_DEL, valu, ()))
 
-                await sync()
+                if doapply:
+                    addedits = editor.getNodeEdits()
+                    if addedits:
+                        await runt.snap.view.parent.storNodeEdits(addedits, meta=meta)
+
+                    if subs:
+                        subedits = [(node.buid, node.form.name, subs)]
+                        await runt.snap.view.storNodeEdits(subedits, meta=meta)
 
                 runt.snap.clearCachedNode(node.buid)
                 yield await runt.snap.getNodeByBuid(node.buid), path

synapse/lib/stormlib/storm.py

@@ -1,18 +1,102 @@
 import logging
 
 import synapse.exc as s_exc
+import synapse.common as s_common
 
+import synapse.lib.storm as s_storm
 import synapse.lib.stormtypes as s_stormtypes
 
 evaldesc = '''\
-Evaluate a storm runtime value and optionally cast/coerce it.
+Evaluate a Storm runtime value and optionally cast/coerce it.
 
-NOTE: If storm logging is enabled, the expression being evaluated will be logged
-separately.
+Note:
+    If Storm logging is enabled, the expression being evaluated will be logged
+    separately.
+'''
+
+rundesc = '''
+Run a Storm query and yield the messages output by the Storm interpreter.
+
+Note:
+    If Storm logging is enabled, the query being run will be logged separately.
 '''
 
 stormlogger = logging.getLogger('synapse.storm')
 
+class StormExecCmd(s_storm.Cmd):
+    '''
+    Execute text or an embedded query object as Storm in the current pipeline.
+
+    NOTE: It is recommended to avoid using this where possible to avoid potential
+    query injection risks. If you must use this, take care to ensure any values
+    being executed have been properly sanitized.
+
+    Examples:
+
+        // Add nodes using text in a variable
+        $query = '[ inet:fqdn=foo.com inet:fqdn=bar.net ]'
+        storm.exec $query
+
+        // Filter nodes in the pipeline using text in a variable
+        $filter = '-:asn=10'
+        inet:ipv4:asn
+        storm.exec $filter
+
+        // Pivot using an embedded query
+        $pivot = ${ -> inet:asn }
+        inet:ipv4:asn
+        storm.exec $pivot
+    '''
+    name = 'storm.exec'
+    def getArgParser(self):
+        pars = s_storm.Cmd.getArgParser(self)
+        pars.add_argument('query', help='The Storm to execute.')
+        return pars
+
+    async def execStormCmd(self, runt, genr):
+
+        if self.runtsafe:
+
+            text = await s_stormtypes.tostr(self.opts.query)
+            query = await runt.getStormQuery(text)
+
+            extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
+            stormlogger.info(f'Executing storm query via storm.exec {{{text}}} as [{self.runt.user.name}]', extra=extra)
+
+            async with runt.getSubRuntime(query) as subr:
+                async for subp in subr.execute(genr=genr):
+                    yield subp
+
+        else:
+
+            item = None
+            async for item in genr:
+                break
+
+            text = await s_stormtypes.tostr(self.opts.query)
+            query = await runt.getStormQuery(text)
+
+            extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
+            stormlogger.info(f'Executing storm query via storm.exec {{{text}}} as [{self.runt.user.name}]', extra=extra)
+
+            async with runt.getSubRuntime(query) as subr:
+                async for subp in subr.execute(genr=s_common.agen(item)):
+                    yield subp
+
+                async for item in genr:
+                    text = await s_stormtypes.tostr(self.opts.query)
+                    query = await runt.getStormQuery(text)
+
+                    subr.runtvars.clear()
+                    subr.query = query
+                    subr._initRuntVars(query)
+
+                    extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
+                    stormlogger.info(f'Executing storm query via storm.exec {{{text}}} as [{self.runt.user.name}]', extra=extra)
+
+                    async for subp in subr.execute(genr=s_common.agen(item)):
+                        yield subp
+
 @s_stormtypes.registry.registerLib
 class LibStorm(s_stormtypes.Lib):
     '''
@@ -25,15 +109,43 @@ class LibStorm(s_stormtypes.Lib):
                       {'name': 'text', 'type': 'str', 'desc': 'A storm expression string.'},
                       {'name': 'cast', 'type': 'str', 'desc': 'A type to cast the result to.', 'default': None},
                   ),
-                  'returns': {'type': 'any', 'desc': 'The value of the expression and optional cast.', }}},
+                  'returns': {'type': 'any', 'desc': 'The value of the expression and optional cast.'}}},
+        {'name': 'run', 'desc': rundesc,
+         'type': {'type': 'function', '_funcname': '_runStorm',
+                  'args': (
+                      {'name': 'query', 'type': 'str', 'desc': 'A Storm query string.'},
+                      {'name': 'opts', 'type': 'dict', 'desc': 'Storm options dictionary.', 'default': None},
+                  ),
+                  'returns': {'name': 'yields', 'type': 'list', 'desc': 'The output messages from the Storm runtime.'}}},
     )
     _storm_lib_path = ('storm',)
 
     def getObjLocals(self):
         return {
+            'run': self._runStorm,
             'eval': self._evalStorm,
         }
 
+    async def _runStorm(self, query, opts=None):
+
+        opts = await s_stormtypes.toprim(opts)
+        query = await s_stormtypes.tostr(query)
+
+        if opts is None:
+            opts = {}
+
+        user = opts.get('user')
+        if user is None:
+            user = opts['user'] = self.runt.user.iden
+
+        if user != self.runt.user.iden:
+            self.runt.confirm(('impersonate',))
+
+        opts.setdefault('view', self.runt.snap.view.iden)
+
+        async for mesg in self.runt.snap.view.core.storm(query, opts=opts):
+            yield mesg
+
     @s_stormtypes.stormfunc(readonly=True)
     async def _evalStorm(self, text, cast=None):
 
@@ -41,7 +153,7 @@ class LibStorm(s_stormtypes.Lib):
         cast = await s_stormtypes.tostr(cast, noneok=True)
 
         if self.runt.snap.core.stormlog:
-            extra = await self.runt.snap.core.getLogExtra(text=text)
+            extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
             stormlogger.info(f'Executing storm query via $lib.storm.eval() {{{text}}} as [{self.runt.user.name}]', extra=extra)
 
         casttype = None

synapse/lib/types.py

@@ -1402,7 +1402,7 @@ class Loc(Type):
 
 class Ndef(Type):
 
-    stortype = s_layer.STOR_TYPE_MSGP
+    stortype = s_layer.STOR_TYPE_NDEF
 
     def postTypeInit(self):
         self.setNormFunc(list, self._normPyTuple)

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

synapse/models/inet.py

@@ -1519,6 +1519,7 @@ class InetModule(s_module.CoreModule):
                         'doc': 'An object status enumeration.'}),
 
                     ('inet:service:account', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
                         'doc': 'An account within a service platform. Accounts may be instance specific.'}),
 
                     ('inet:service:permission:type:taxonomy', ('taxonomy', {}), {
@@ -1557,6 +1558,10 @@ class InetModule(s_module.CoreModule):
                         'interfaces': ('inet:service:object',),
                         'doc': 'A channel used to distribute messages.'}),
 
+                    ('inet:service:thread', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A message thread.'}),
+
                     ('inet:service:channel:member', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
                         'doc': 'Represents a service account being a member of a channel.'}),
@@ -3657,9 +3662,15 @@ class InetModule(s_module.CoreModule):
                         ('channel', ('inet:service:channel', {}), {
                             'doc': 'The channel that the message was sent to.'}),
 
+                        ('thread', ('inet:service:thread', {}), {
+                            'doc': 'The thread which contains the message.'}),
+
                         ('public', ('bool', {}), {
                             'doc': 'Set to true if the message is publicly visible.'}),
 
+                        ('title', ('str', {'lower': True, 'onespace': True}), {
+                            'doc': 'The message title.'}),
+
                         ('text', ('str', {}), {
                             'disp': {'hint': 'text'},
                             'doc': 'The text body of the message.'}),
@@ -3725,6 +3736,18 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The time period where the channel was available.'}),
                     )),
 
+                    ('inet:service:thread', {}, (
+
+                        ('title', ('str', {'lower': True, 'onespace': True}), {
+                            'doc': 'The title of the thread.'}),
+
+                        ('channel', ('inet:service:channel', {}), {
+                            'doc': 'The channel that contains the thread.'}),
+
+                        ('message', ('inet:service:message', {}), {
+                            'doc': 'The message which initiated the thread.'}),
+                    )),
+
                     ('inet:service:channel:member', {}, (
 
                         ('channel', ('inet:service:channel', {}), {