synapse 2.190.0__py311-none-any.whl → 2.191.0__py311-none-any.whl

synapse/common.py

@@ -1368,3 +1368,12 @@ def _timeout(delay):
     """
     loop = asyncio.get_running_loop()
     return _Timeout(loop.time() + delay if delay is not None else None)
+
+def format(text, **kwargs):
+    '''
+    Similar to python str.format() but treats tokens as opaque.
+    '''
+    for name, valu in kwargs.items():
+        tokn = '{' + name + '}'
+        text = text.replace(tokn, valu)
+    return text

synapse/cortex.py

@@ -4651,6 +4651,7 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
         # allow an admin to directly open the cortex hive
         # (perhaps this should be a Cell() level pattern)
         if path[0] == 'hive' and user.isAdmin():
+            s_common.deprecated('Cortex /hive telepath path', curv='2.167.0')
             return await self.hiveapi.anit(self.hive, user)
 
         if path[0] == 'layer':

synapse/datamodel.py

@@ -1114,7 +1114,14 @@ class Model:
                 if item == '$self':
                     return form.name
 
-                return item.format(**template)
+                item = s_common.format(item, **template)
+
+                # warn but do not blow up. there may be extended model elements
+                # with {}s which are not used for templates...
+                if item.find('{') != -1: # pragma: no cover
+                    logger.warning(f'Missing template specifier in: {item}')
+
+                return item
 
             if isinstance(item, dict):
                 return {convert(k): convert(v) for (k, v) in item.items()}

synapse/lib/cell.py

@@ -96,16 +96,16 @@ def adminapi(log=False):
     def decrfunc(func):
 
         @functools.wraps(func)
-        def wrapped(*args, **kwargs):
+        def wrapped(self, *args, **kwargs):
 
-            if args[0].user is not None and not args[0].user.isAdmin():
-                raise s_exc.AuthDeny(mesg='User is not an admin.',
-                                     user=args[0].user.name)
+            if self.user is not None and not self.user.isAdmin():
+                raise s_exc.AuthDeny(mesg=f'User is not an admin [{self.user.name}]',
+                                     user=self.user.iden, username=self.user.name)
             if log:
-                logger.info('Executing [%s] as [%s] with args [%s][%s]',
-                            func.__qualname__, args[0].user.name, args[1:], kwargs)
+                logger.info(f'Executing [{func.__qualname__}] as [{self.user.name}] with args [{args}[{kwargs}]',
+                            extra={'synapse': {'wrapped_func': func.__qualname__}})
 
-            return func(*args, **kwargs)
+            return func(self, *args, **kwargs)
 
         wrapped.__syn_wrapped__ = 'adminapi'
 

synapse/lib/msgpack.py

@@ -26,8 +26,16 @@ def _ext_en(item):
             return msgpack.ExtType(1, item.to_bytes(size, 'big', signed=True))
     return item
 
+_packer_kwargs = {
+    'use_bin_type': True,
+    'unicode_errors': 'surrogatepass',
+    'default': _ext_en,
+}
+if msgpack.version >= (1, 1, 0):
+    _packer_kwargs['buf_size'] = 1024 * 1024
+
 # Single Packer object which is reused for performance
-pakr = msgpack.Packer(use_bin_type=True, unicode_errors='surrogatepass', default=_ext_en)
+pakr = msgpack.Packer(**_packer_kwargs)
 if isinstance(pakr, m_fallback.Packer):  # pragma: no cover
     logger.warning('******************************************************************************************************')
     logger.warning('* msgpack is using the pure python fallback implementation. This will impact performance negatively. *')
@@ -87,8 +95,7 @@ def _fallback_en(item):
         bytes: The serialized bytes in msgpack format.
     '''
     try:
-        return msgpack.packb(item, use_bin_type=True,
-                             unicode_errors='surrogatepass', default=_ext_en)
+        return msgpack.packb(item, **_packer_kwargs)
     except TypeError as e:
         mesg = f'{e.args[0]}: {repr(item)[:20]}'
         raise s_exc.NotMsgpackSafe(mesg=mesg) from e

synapse/lib/stormlib/model.py

@@ -916,6 +916,21 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                        'desc': 'Do not copy nodedata to the inet:tls:servercert node.'},
                  ),
                  'returns': {'type': 'node', 'desc': 'The newly created inet:tls:servercert node.'}}},
+        {'name': 'inetServiceMessageClientAddress', 'desc': '''
+            Migrate the :client:address property to :client on inet:service:message nodes.
+
+            Edits will be made to the inet:service:message node in the current write layer.
+
+            If the :client:address property is set and the :client property is not set,
+            the :client property will be set with the :client:address value. If both
+            properties are set, the value will be moved into nodedata under the key
+            'migration:inet:service:message:address'.
+        ''',
+        'type': {'type': 'function', '_funcname': '_storm_query',
+                 'args': (
+                      {'name': 'n', 'type': 'node', 'desc': 'The inet:sevice:message node to migrate.'},
+                 ),
+                 'returns': {'type': 'null'}}},
 
     )
     _storm_lib_path = ('model', 'migration', 's')
@@ -956,6 +971,28 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
 
             return($node)
         }
+
+        function inetServiceMessageClientAddress(n) {
+            $form = $n.form()
+            if ($form != 'inet:service:message') {
+                $mesg = `$lib.model.migration.s.inetServiceMessageClientAddress() only accepts inet:service:message nodes, not {$form}`
+                $lib.raise(BadArg, $mesg)
+            }
+
+            if (not $n.props.'client:address') { return() }
+
+            yield $n
+
+            if :client {
+                $node.data.set(migration:inet:service:message:client:address, :client:address)
+            } else {
+                [ :client = :client:address ]
+            }
+
+            [ -:client:address ]
+
+            return()
+        }
     '''
 
     def getObjLocals(self):

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, 190, 0)
+version = (2, 191, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = 'ea92cb42c33f8793e9d72834aa8d12b6456eee8b'
+commit = 'f6b07ada7cb68701e769e155735c9c004a404454'

synapse/models/auth.py

@@ -43,7 +43,8 @@ class AuthModule(s_module.CoreModule):
                         'doc': 'The WiFi SSID that the credentials allow access to.',
                     }),
                     ('web:acct', ('inet:web:acct', {}), {
-                        'doc': 'The web account that the credentials allow access to.',
+                        'deprecated': True,
+                        'doc': 'Deprecated. Use :service:account.',
                     }),
                     ('service:account', ('inet:service:account', {}), {
                         'doc': 'The service account that the credentials allow access to.'}),

synapse/models/base.py

@@ -56,6 +56,10 @@ class BaseModule(s_module.CoreModule):
                     'interfaces': ('meta:taxonomy',),
                     'doc': 'A taxonomy of event types for meta:event nodes.'}),
 
+                ('meta:ruleset:type:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy for meta:ruleset types.'}),
+
                 ('meta:ruleset', ('guid', {}), {
                     'doc': 'A set of rules linked with -(has)> edges.'}),
 
@@ -99,6 +103,9 @@ class BaseModule(s_module.CoreModule):
                     'deprecated': True,
                     'doc': 'A generic digraph time edge to show relationships outside the model.'}),
 
+                ('meta:activity', ('int', {'enums': prioenums, 'enums:strict': False}), {
+                    'doc': 'A generic activity level enumeration.'}),
+
                 ('meta:priority', ('int', {'enums': prioenums, 'enums:strict': False}), {
                     'doc': 'A generic priority enumeration.'}),
 
@@ -120,6 +127,9 @@ class BaseModule(s_module.CoreModule):
                         ),
                     },
                     'doc': 'A node which represents an aggregate count of a specific type.'}),
+
+                ('markdown', ('str', {}), {
+                    'doc': 'A markdown string.'}),
             ),
             'interfaces': (
                 ('meta:taxonomy', {
@@ -182,6 +192,12 @@ class BaseModule(s_module.CoreModule):
 
                     ('url', ('inet:url', {}), {
                         'doc': 'A URL which documents the meta source.'}),
+
+                    ('ingest:latest', ('time', {}), {
+                        'doc': 'Used by ingest logic to capture the last time a feed ingest ran.'}),
+
+                    ('ingest:offset', ('int', {}), {
+                        'doc': 'Used by ingest logic to capture the current ingest offset within a feed.'}),
                 )),
 
                 ('meta:seen', {}, (
@@ -263,6 +279,10 @@ class BaseModule(s_module.CoreModule):
                 ('meta:ruleset', {}, (
                     ('name', ('str', {'lower': True, 'onespace': True}), {
                         'doc': 'A name for the ruleset.'}),
+
+                    ('type', ('meta:ruleset:type:taxonomy', {}), {
+                        'doc': 'The ruleset type.'}),
+
                     ('desc', ('str', {}), {
                         'disp': {'hint': 'text'},
                         'doc': 'A description of the ruleset.'}),

synapse/models/crypto.py

@@ -82,6 +82,11 @@ class CryptoModule(s_module.CoreModule):
                     'ex': 'btc',
                 }),
                 ('crypto:currency:address', ('comp', {'fields': (('coin', 'crypto:currency:coin'), ('iden', 'str')), 'sepr': '/'}), {
+
+                    'interfaces': ('econ:pay:instrument',),
+                    'template': {
+                        'instrument': 'crypto currency address'},
+
                     'doc': 'An individual crypto currency address.',
                     'ex': 'btc/1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2',
                 }),
@@ -364,8 +369,6 @@ class CryptoModule(s_module.CoreModule):
                         'doc': 'The coin specific address identifier.', 'ro': True, }),
                     ('desc', ('str', {}), {
                         'doc': 'A free-form description of the address.'}),
-                    ('contact', ('ps:contact', {}), {
-                        'doc': 'Contact information associated with the address.'}),
                 )),
 
                 ('crypto:algorithm', {}, ()),

synapse/models/economic.py

@@ -23,6 +23,11 @@ class EconModule(s_module.CoreModule):
                     'doc': 'An Issuer Id Number (IIN).'}),
 
                 ('econ:pay:card', ('guid', {}), {
+
+                    'interfaces': ('econ:pay:instrument',),
+                    'template': {
+                        'instrument': 'payment card'},
+
                     'doc': 'A single payment card.'}),
 
                 ('econ:purchase', ('guid', {}), {
@@ -71,6 +76,11 @@ class EconModule(s_module.CoreModule):
                     'doc': 'A bank account type taxonomy.'}),
 
                 ('econ:bank:account', ('guid', {}), {
+
+                    'interfaces': ('econ:pay:instrument',),
+                    'template': {
+                        'instrument': 'bank account'},
+
                     'doc': 'A bank account.'}),
 
                 ('econ:bank:balance', ('guid', {}), {
@@ -87,6 +97,25 @@ class EconModule(s_module.CoreModule):
 
                 ('econ:bank:swift:bic', ('str', {'regex': '[A-Z]{6}[A-Z0-9]{5}'}), {
                     'doc': 'A Society for Worldwide Interbank Financial Telecommunication (SWIFT) Business Identifier Code (BIC).'}),
+
+                ('econ:pay:instrument', ('ndef', {'interface': 'econ:pay:instrument'}), {
+                    'doc': 'A node which may act as a payment instrument.'}),
+            ),
+
+            'interfaces': (
+                ('econ:pay:instrument', {
+
+                    'doc': 'An interface for forms which may act as a payment instrument.',
+                    'template': {
+                        'instrument': 'instrument',
+                    },
+
+                    'props': (
+
+                        ('contact', ('ps:contact', {}), {
+                            'doc': 'The primary contact for the {instrument}.'}),
+                    ),
+                }),
             ),
 
             'edges': (
@@ -134,9 +163,6 @@ class EconModule(s_module.CoreModule):
 
                     ('account', ('econ:bank:account', {}), {
                         'doc': 'A bank account associated with the payment card.'}),
-
-                    ('contact', ('ps:contact', {}), {
-                        'doc': 'The contact information associated with the payment card.'}),
                 )),
 
                 ('econ:purchase', {}, (
@@ -209,17 +235,26 @@ class EconModule(s_module.CoreModule):
                     ('from:cash', ('bool', {}), {
                         'doc': 'Set to true if the payment input was in cash.'}),
 
+                    ('to:instrument', ('econ:pay:instrument', {}), {
+                        'doc': 'The payment instrument which received funds from the payment.'}),
+
+                    ('from:instrument', ('econ:pay:instrument', {}), {
+                        'doc': 'The payment instrument used to make the payment.'}),
+
                     ('from:account', ('econ:bank:account', {}), {
-                        'doc': 'The bank account which made the payment.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use :from:instrument.'}),
 
                     ('from:pay:card', ('econ:pay:card', {}), {
-                        'doc': 'The payment card making the payment.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use :from:instrument.'}),
 
                     ('from:contract', ('ou:contract', {}), {
                         'doc': 'A contract used as an aggregate payment source.'}),
 
                     ('from:coinaddr', ('crypto:currency:address', {}), {
-                        'doc': 'The crypto currency address making the payment.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use :from:instrument.'}),
 
                     ('from:contact', ('ps:contact', {}), {
                         'doc': 'Contact information for the entity making the payment.'}),
@@ -228,10 +263,12 @@ class EconModule(s_module.CoreModule):
                         'doc': 'Set to true if the payment output was in cash.'}),
 
                     ('to:account', ('econ:bank:account', {}), {
-                        'doc': 'The bank account which received the payment.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use :to:instrument.'}),
 
                     ('to:coinaddr', ('crypto:currency:address', {}), {
-                        'doc': 'The crypto currency address receiving the payment.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use :to:instrument.'}),
 
                     ('to:contact', ('ps:contact', {}), {
                         'doc': 'Contact information for the person/org being paid.'}),
@@ -448,9 +485,6 @@ class EconModule(s_module.CoreModule):
                     ('iban', ('econ:bank:iban', {}), {
                         'doc': 'The IBAN for the account.'}),
 
-                    ('contact', ('ps:contact', {}), {
-                        'doc': 'The contact information associated with the bank account.'}),
-
                     ('issuer', ('ou:org', {}), {
                         'doc': 'The bank which issued the account.'}),
 

synapse/models/inet.py

@@ -1530,7 +1530,8 @@ class InetModule(s_module.CoreModule):
                         'doc': 'An object status enumeration.'}),
 
                     ('inet:service:account', ('guid', {}), {
-                        'interfaces': ('inet:service:object',),
+                        'interfaces': ('inet:service:subscriber',),
+                        'template': {'service:base': 'account'},
                         'doc': 'An account within a service platform. Accounts may be instance specific.'}),
 
                     ('inet:service:relationship:type:taxonomy', ('taxonomy', {}), {
@@ -1539,6 +1540,7 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:relationship', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'relationship'},
                         'doc': 'A relationship between two service objects.'}),
 
                     ('inet:service:permission:type:taxonomy', ('taxonomy', {}), {
@@ -1547,10 +1549,12 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:permission', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'permission'},
                         'doc': 'A permission which may be granted to a service account or role.'}),
 
                     ('inet:service:rule', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'rule'},
                         'doc': 'A rule which grants or denies a permission to a service account or role.'}),
 
                     ('inet:service:login', ('guid', {}), {
@@ -1563,26 +1567,32 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:session', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'session'},
                         'doc': 'An authenticated session.'}),
 
                     ('inet:service:group', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'group'},
                         'doc': 'A group or role which contains member accounts.'}),
 
                     ('inet:service:group:member', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'group membership'},
                         'doc': 'Represents a service account being a member of a group.'}),
 
                     ('inet:service:channel', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'channel'},
                         'doc': 'A channel used to distribute messages.'}),
 
                     ('inet:service:thread', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'thread'},
                         'doc': 'A message thread.'}),
 
                     ('inet:service:channel:member', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'channel membership'},
                         'doc': 'Represents a service account being a member of a channel.'}),
 
                     ('inet:service:message', ('guid', {}), {
@@ -1601,26 +1611,47 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:emote', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'emote'},
                         'doc': 'An emote or reaction by an account.'}),
 
                     ('inet:service:access', ('guid', {}), {
                         'interfaces': ('inet:service:action',),
                         'doc': 'Represents a user access request to a service resource.'}),
 
+                    ('inet:service:tenant', ('guid', {}), {
+                        'interfaces': ('inet:service:subscriber',),
+                        'template': {'service:base': 'tenant'},
+                        'doc': 'A tenant which groups accounts and instances.'}),
+
+                    ('inet:service:subscription:level:taxonomy', ('taxonomy', {}), {
+                        'interfaces': ('meta:taxonomy',),
+                        'doc': 'A taxonomy of platform specific subscription levels.'}),
+
+                    ('inet:service:subscription', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'subscription'},
+                        'doc': 'A subscription to a service platform or instance.'}),
+
+                    ('inet:service:subscriber', ('ndef', {'interface': 'inet:service:subscriber'}), {
+                        'doc': 'A node which may subscribe to a service subscription.'}),
+
                     ('inet:service:resource:type:taxonomy', ('taxonomy', {}), {
                         'interfaces': ('meta:taxonomy',),
                         'doc': 'A taxonomy of inet service resource types.'}),
 
                     ('inet:service:resource', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'resource'},
                         'doc': 'A generic resource provided by the service architecture.'}),
 
                     ('inet:service:bucket', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'bucket'},
                         'doc': 'A file/blob storage object within a service architecture.'}),
 
                     ('inet:service:bucket:item', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'bucket item'},
                         'doc': 'An individual file stored within a bucket.'}),
 
                     ('inet:tls:handshake', ('guid', {}), {
@@ -1676,16 +1707,17 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:base', {
                         'doc': 'Properties common to most forms within a service platform.',
+                        'template': {'service:base': 'node'},
                         'props': (
 
                             ('id', ('str', {'strip': True}), {
-                                'doc': 'A platform specific ID.'}),
+                                'doc': 'A platform specific ID which identifies the {service:base}.'}),
 
                             ('platform', ('inet:service:platform', {}), {
-                                'doc': 'The platform which defines the node.'}),
+                                'doc': 'The platform which defines the {service:base}.'}),
 
                             ('instance', ('inet:service:instance', {}), {
-                                'doc': 'The platform instance which defines the node.'}),
+                                'doc': 'The platform instance which defines the {service:base}.'}),
                         ),
                     }),
 
@@ -1693,23 +1725,34 @@ class InetModule(s_module.CoreModule):
 
                         'doc': 'Properties common to objects within a service platform.',
                         'interfaces': ('inet:service:base',),
+                        'template': {'service:base': 'object'},
                         'props': (
 
                             ('status', ('inet:service:object:status', {}), {
-                                'doc': 'The status of this object.'}),
+                                'doc': 'The status of the {service:base}.'}),
 
                             ('period', ('ival', {}), {
-                                'doc': 'The period when the object existed.'}),
+                                'doc': 'The period when the {service:base} existed.'}),
 
                             ('creator', ('inet:service:account', {}), {
-                                'doc': 'The service account which created the object.'}),
+                                'doc': 'The service account which created the {service:base}.'}),
 
                             ('remover', ('inet:service:account', {}), {
-                                'doc': 'The service account which removed or decommissioned the object.'}),
+                                'doc': 'The service account which removed or decommissioned the {service:base}.'}),
 
                         ),
                     }),
 
+                    ('inet:service:subscriber', {
+                        'doc': 'Properties common to the nodes which subscribe to services.',
+                        'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'subscriber'},
+                        'props': (
+                            ('profile', ('ps:contact', {}), {
+                                'doc': 'The primary contact information for the {service:base}.'}),
+                        ),
+                    }),
+
                     ('inet:service:action', {
 
                         'doc': 'Properties common to events within a service platform.',
@@ -3590,21 +3633,21 @@ class InetModule(s_module.CoreModule):
 
                         ('owner', ('inet:service:account', {}), {
                             'doc': 'The service account which owns the instance.'}),
+
+                        ('tenant', ('inet:service:tenant', {}), {
+                            'doc': 'The tenant which contains the instance.'}),
                     )),
 
                     ('inet:service:account', {}, (
 
-                        ('id', ('str', {'strip': True}), {
-                            'doc': 'A platform specific ID used to identify the account.'}),
-
                         ('user', ('inet:user', {}), {
                             'doc': 'The current user name of the account.'}),
 
                         ('email', ('inet:email', {}), {
                             'doc': 'The current email address associated with the account.'}),
 
-                        ('profile', ('ps:contact', {}), {
-                            'doc': 'Current profile details associated with the account.'}),
+                        ('tenant', ('inet:service:tenant', {}), {
+                            'doc': 'The tenant which contains the account.'}),
                     )),
 
                     ('inet:service:relationship:type:taxonomy', {}, ()),
@@ -3621,10 +3664,7 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The type of relationship between the source and the target.'}),
                     )),
 
-                    ('inet:service:group', {}, ( # inet:service:object
-
-                        ('id', ('str', {'strip': True}), {
-                            'doc': 'A platform specific ID used to identify the group.'}),
+                    ('inet:service:group', {}, (
 
                         ('name', ('inet:group', {}), {
                             'doc': 'The name of the group on this platform.'}),
@@ -3674,14 +3714,14 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:session', {}, (
 
-                        ('id', ('str', {'strip': True}), {
-                            'doc': 'The service specific session id.'}),
-
                         ('creator', ('inet:service:account', {}), {
                             'doc': 'The account which authenticated to create the session.'}),
 
                         ('period', ('ival', {}), {
                             'doc': 'The period where the session was valid.'}),
+
+                        ('http:session', ('inet:http:session', {}), {
+                            'doc': 'The HTTP session associated with the service session.'}),
                     )),
 
                     ('inet:service:login', {}, (
@@ -3742,7 +3782,8 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The name of the place that the message was sent from.'}),
 
                         ('client:address', ('inet:client', {}), {
-                            'doc': 'The client address that the message was sent from.'}),
+                            'deprecated': True,
+                            'doc': 'Deprecated. Please use :client'}),
 
                         ('client:software', ('it:prod:softver', {}), {
                             'doc': 'The client software version used to send the message.'}),
@@ -3864,6 +3905,22 @@ class InetModule(s_module.CoreModule):
                         ('type', ('int', {'enums': svcaccesstypes}), {
                             'doc': 'The type of access requested.'}),
                     )),
+
+                    ('inet:service:tenant', {}, ()),
+
+                    ('inet:service:subscription:level:taxonomy', {}, ()),
+
+                    ('inet:service:subscription', {}, (
+
+                        ('level', ('inet:service:subscription:level:taxonomy', {}), {
+                            'doc': 'A platform specific subscription level.'}),
+
+                        ('pay:instrument', ('econ:pay:instrument', {}), {
+                            'doc': 'The primary payment instrument used to pay for the subscription.'}),
+
+                        ('subscriber', ('inet:service:subscriber', {}), {
+                            'doc': 'The subscriber who owns the subscription.'}),
+                    )),
                 ),
             }),
         )