session_hosted_service.py 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297
  1. """Authority-bound hosted service; no legacy session server is constructed."""
  2. import asyncio
  3. import hashlib
  4. from contextlib import nullcontext
  5. from pathlib import Path
  6. from gateway.session_contract import SessionActor
  7. from gateway.session_authorities import active_authority, all_authorities, owner_scope, serving_authorities
  8. from gateway.session_hosted_controls import HostedControls
  9. from gateway.owner_identity import same_owner
  10. from hermes_state_runtime import RuntimeStoreError, _epoch
  11. from tui_gateway.hosted_room_service import HostedRoomService
  12. _OWNER = 'gateway.hosted.owner.v1:'
  13. def probe_native_room_owner(db_path, *, room_id) -> bool:
  14. """Non-blocking, read-only: does the gateway owning this session store serve ``room_id``? Only rooms
  15. with an owner entry are in ``CanonicalHostedRoomService.bindings``."""
  16. from gateway.hosted_rooms import _probe
  17. return _probe(Path(db_path), 'state_meta', 'SELECT 1 FROM state_meta WHERE key=? LIMIT 1',
  18. (_OWNER + str(room_id),), 'native room ownership is temporarily unavailable')
  19. class CanonicalHostedRoomService(HostedControls, HostedRoomService):
  20. def __init__(self, authority, loop):
  21. self.authority, self.loop = authority, loop
  22. self.member_rpcs = {}
  23. super().__init__(None, db_path=authority.db.db_path)
  24. def _make_rpc(self, server):
  25. # Member-specific canonical transports retain exact durable history. They
  26. # intentionally use the runtime's receipt-capable (non-legacy) recovery path.
  27. return self
  28. def profile_homes(self):
  29. from gateway.session_hosted_members import member_roster
  30. return member_roster(self.authority)[0]
  31. def local_profiles(self):
  32. return tuple(self.profile_homes())
  33. def room_profiles(self, room):
  34. """A saved room keeps every local member it seated: unserving one bot must not stop the
  35. others. That member's own turns still fail (``_resolve_member_transport`` and ``attest``
  36. need a live home), and a new group cannot seat it (``local_profiles``)."""
  37. seated = {m.get('profile') for m in room.get('members') or ()
  38. if isinstance(m, dict) and isinstance(m.get('profile'), str)
  39. and (m.get('target') or {}).get('kind', 'local') == 'local'}
  40. return tuple(sorted(set(self.local_profiles()) | seated))
  41. def attest(self, selector, operation, params):
  42. from dataclasses import asdict
  43. from gateway.hosted_room_driver import list_tasks
  44. if set(selector) != {'room_id', 'member_id', 'profile'}:
  45. raise RuntimeStoreError('invalid_params')
  46. room_id, member, profile = (selector[k] for k in ('room_id', 'member_id', 'profile'))
  47. owner = self._owner(room_id)
  48. self._owned_authority(room_id)
  49. room = self._room(room_id)
  50. if not any(m['member_id'] == member and m['profile'] == profile
  51. and m.get('target', {}).get('kind', 'local') == 'local' for m in room['members']):
  52. raise RuntimeStoreError('permission_denied')
  53. target_home = self.profile_homes().get(profile)
  54. if target_home is None or params.get('_target_home') != str(target_home):
  55. raise RuntimeStoreError('permission_denied')
  56. result = {'owner': owner, 'target_home': str(target_home)}
  57. if operation in {'submit', 'execute', 'attachment'}:
  58. matches = [t for t in list_tasks(self.db_path, room_id=room_id)
  59. if asdict(t['identity']) == params.get('task')
  60. and t['execution_generation'] == params.get('execution_generation')
  61. and t['status'] == 'running'
  62. and t['payload'].get('target_member_id', t['payload']['target_profile']) == member
  63. and t['payload']['target_profile'] == profile
  64. and (operation == 'execute' or (
  65. (hashlib.sha256(t['payload']['prompt'].encode('utf-8')).hexdigest()
  66. == params['prompt_sha256'] if 'prompt_sha256' in params
  67. else t['payload']['prompt'] == params.get('prompt'))
  68. and t['payload'].get('attachments', []) == (params.get('attachments') or [])))]
  69. if len(matches) != 1:
  70. raise RuntimeStoreError('permission_denied')
  71. payload = matches[0]['payload']
  72. if operation == 'attachment':
  73. # Bytes only: the prompt/manifest already attested for the submit would
  74. # otherwise compete with the chunk for the bounded response line.
  75. from gateway.session_hosted_transport import source_attachment_chunk
  76. result.update(source_attachment_chunk(self, member, room_id, payload.get('attachments', []), params))
  77. else:
  78. from gateway.session_hosted_transport import source_attachment_digests
  79. manifest = payload.get('attachments', [])
  80. result.update(prompt=payload['prompt'], attachments=manifest,
  81. attachment_digests=source_attachment_digests(self, member, room_id, manifest))
  82. return result
  83. def bindings(self):
  84. with self.authority.db._read_ctx() as conn:
  85. owned = {r[0][len(_OWNER):] for r in conn.execute(
  86. 'SELECT key FROM state_meta WHERE key LIKE ?', (_OWNER + '%',))}
  87. return tuple(b for b in super().bindings() if b.room_id in owned)
  88. def _turn_lock(self, profile):
  89. return nullcontext()
  90. def authorize_room(self, actor_subject, room_id, *, create=False, conn=None):
  91. """Check (or, with ``create``, claim) room ownership. A ``conn`` runs the claim inside
  92. the caller's room-creation transaction, so owner and room commit or roll back together."""
  93. from gateway.hosted_rooms_common import IDENTIFIER_RE
  94. if (not isinstance(actor_subject, str) or not actor_subject
  95. or not isinstance(room_id, str) or len(room_id) > 128
  96. or not IDENTIFIER_RE.fullmatch(room_id)):
  97. raise RuntimeStoreError('invalid_params')
  98. def write(conn):
  99. _epoch(conn, self.authority.epoch)
  100. key = _OWNER + room_id
  101. row = conn.execute('SELECT value FROM state_meta WHERE key=?', (key,)).fetchone()
  102. if row is None and create:
  103. historical = conn.execute(
  104. 'SELECT 1 FROM hosted_rooms WHERE room_id=? UNION ALL '
  105. 'SELECT 1 FROM hosted_room_retired_ids WHERE room_id=?',
  106. (room_id, room_id)).fetchone()
  107. if historical is None:
  108. conn.execute('INSERT INTO state_meta(key,value) VALUES(?,?)', (key, actor_subject))
  109. return True
  110. if row is None or not same_owner(row[0], actor_subject):
  111. raise RuntimeStoreError('permission_denied')
  112. return True
  113. return write(conn) if conn is not None else self.authority.db._execute_write(write)
  114. def _owner(self, room_id):
  115. with self.authority.db._read_ctx() as conn:
  116. row = conn.execute('SELECT value FROM state_meta WHERE key=?', (_OWNER + room_id,)).fetchone()
  117. if row is None:
  118. raise RuntimeStoreError('permission_denied')
  119. return row[0]
  120. def _resolve_member_transport(self, binding, task):
  121. if self._member_is_peer(binding.room_id, str(task['payload'].get('target_member_id') or task['payload'].get('target_profile'))):
  122. return super()._resolve_member_transport(binding, task)
  123. from gateway.session_hosted_rpc import HostedRoomAuthorityRPC
  124. payload = task['payload']
  125. member = str(payload.get('target_member_id') or payload.get('target_profile'))
  126. profile = payload['target_profile']
  127. owner = self._owner(binding.room_id)
  128. home = self.profile_homes().get(profile)
  129. if home is None:
  130. raise RuntimeStoreError('permission_denied')
  131. key = binding.room_id, member, profile, owner, str(home)
  132. if key not in self.member_rpcs:
  133. if home != Path(self.authority.profile_id):
  134. from gateway.session_hosted_transport import HostedRoomOwnerRPC
  135. self.member_rpcs[key] = HostedRoomOwnerRPC(home=home,
  136. source_home=self.authority.profile_id, room_id=binding.room_id,
  137. member_id=member, profile=profile)
  138. return self.member_rpcs[key]
  139. def authorized(conn, operation, identity, generation):
  140. # Admission checks must share the FIFO writer's snapshot. Opening
  141. # another transaction here would reintroduce the revocation race.
  142. from gateway.hosted_rooms import _room_from_row
  143. from gateway.hosted_room_driver import _task_from_row
  144. _epoch(conn, self.authority.epoch)
  145. owned = conn.execute('SELECT value FROM state_meta WHERE key=?',
  146. (_OWNER + binding.room_id,)).fetchone()
  147. if owned is None or owned[0] != owner:
  148. return False
  149. stored = conn.execute('SELECT * FROM hosted_rooms WHERE room_id=?',
  150. (binding.room_id,)).fetchone()
  151. if stored is None or stored['disbanded_at'] is not None:
  152. return False
  153. room = _room_from_row(stored)
  154. if (room['authority_gateway_id'], room['authority_epoch']) != (binding.gateway_id, binding.authority_epoch):
  155. return False
  156. members = room['members']
  157. if not any(m.get('member_id') == member and m.get('profile') == profile
  158. and (m.get('target') is None or (
  159. isinstance(m.get('target'), dict)
  160. and m['target'].get('kind', 'local') == 'local'))
  161. for m in members):
  162. return False
  163. if self.profile_homes().get(profile) != home:
  164. return False
  165. if identity is not None:
  166. stored = conn.execute('SELECT * FROM hosted_room_driver_tasks WHERE room_id=? AND task_id=?',
  167. (binding.room_id, identity.task_id)).fetchone()
  168. if stored is None:
  169. return False
  170. current = _task_from_row(stored)
  171. return (current['identity'] == identity and current['execution_generation'] == generation
  172. and current['payload'].get('target_profile') == profile
  173. and current['payload'].get('target_member_id', profile) == member
  174. and current['status'] in ({'running'} if operation in {'submit', 'execute'}
  175. else {'running', 'stopping'}))
  176. return True
  177. def authorize(operation, identity, generation):
  178. with self.authority.db._read_ctx() as conn:
  179. return authorized(conn, operation, identity, generation)
  180. def authorize_write(conn, identity, generation):
  181. # Raise to refuse rather than return False: a guard that only returns False
  182. # is ignored wherever the admission hook signals refusal by raising.
  183. if not authorized(conn, 'submit', identity, generation):
  184. raise RuntimeStoreError('permission_denied')
  185. return True
  186. principal = SessionActor(owner, self.authority.profile_id,
  187. frozenset({'session:create', 'session:read', 'session:submit', 'session:control', 'session:approve'}),
  188. 'hosted:' + binding.room_id + ':' + member)
  189. self.member_rpcs[key] = HostedRoomAuthorityRPC(self.authority, self.loop,
  190. room_id=binding.room_id, member_id=member, profile=profile, principal=principal, authorize=authorize,
  191. authorize_write=authorize_write)
  192. return self.member_rpcs[key]
  193. def check_admission(self, ref, row):
  194. """Reconstruct the private producer from durable task state before claim."""
  195. import json
  196. from gateway.hosted_room_driver import TaskIdentity, list_tasks
  197. from gateway.session_hosted_attachments import committed_submission_payload
  198. from tui_gateway.hosted_room_driver import HostedRoomBinding
  199. try:
  200. if not row['request_id'].startswith('hosted:'):
  201. raise ValueError('not a hosted admission')
  202. identity, generation = json.loads(row['request_id'][7:])
  203. identity = TaskIdentity(**identity)
  204. if type(generation) is not int or generation < 1:
  205. raise ValueError('invalid generation')
  206. owner = self._owner(identity.room_id)
  207. if not same_owner(owner, row['principal_id']):
  208. raise ValueError('foreign owner')
  209. room = self._room(identity.room_id)
  210. task = next(t for t in list_tasks(self.db_path, room_id=identity.room_id)
  211. if t['identity'] == identity and t['execution_generation'] == generation)
  212. rpc = self._resolve_member_transport(HostedRoomBinding(identity.room_id,
  213. room['authority_gateway_id'], room['authority_epoch']), task)
  214. if (getattr(rpc, 'ref', None) != ref or task['status'] != 'running'
  215. or row['payload'] != committed_submission_payload(rpc, task['payload']['prompt'], task['payload'].get('attachments'))
  216. or rpc.authorizer('execute', identity, generation) is not True):
  217. raise ValueError('changed hosted binding')
  218. return task
  219. except (ValueError, TypeError, KeyError, StopIteration) as exc:
  220. raise RuntimeStoreError('permission_denied') from exc
  221. def approve(self, *, session_id, request_id, choice):
  222. rpc = next((r for r in self.member_rpcs.values() if r.ref.session_id == session_id), None)
  223. if rpc is None:
  224. raise RuntimeStoreError('permission_denied')
  225. return rpc.approve(session_id=session_id, request_id=request_id, choice=choice)
  226. async def ensure_hosted_service(runner):
  227. """Prepare every transport before readiness can release any coordinator."""
  228. active = active_authority(runner)
  229. if active is None:
  230. raise RuntimeStoreError('profile_mismatch')
  231. for authority in serving_authorities(runner):
  232. await _ensure_hosted_service(runner, authority)
  233. start_ready_hosted_services(runner)
  234. return active.hosted_room_service
  235. async def _ensure_hosted_service(runner, authority):
  236. with owner_scope(authority):
  237. service = getattr(authority, 'hosted_room_service', None)
  238. if service is None:
  239. loop = asyncio.get_running_loop()
  240. from gateway.hosted_rooms_gateway_import import import_standalone_rooms
  241. await asyncio.to_thread(import_standalone_rooms, Path(authority.db.db_path), runtime_epoch=authority.epoch)
  242. service = await asyncio.to_thread(CanonicalHostedRoomService, authority, loop)
  243. authority.hosted_room_service = service
  244. if not getattr(service, '_transport_installed', False):
  245. from gateway.session_hosted_transport import install_hosted_transport
  246. install_hosted_transport(runner.session_control_server, authority, asyncio.get_running_loop(),
  247. attest=service.attest)
  248. service._transport_installed = True
  249. def start_ready_hosted_services(runner):
  250. """Start only a fully prepared served set behind the published ready gate."""
  251. if (getattr(runner, 'session_runtime_descriptor', {}).get('state') != 'ready'
  252. or getattr(runner, '_draining', False)):
  253. return
  254. services = [getattr(authority, 'hosted_room_service', None) for authority in serving_authorities(runner)]
  255. if any(service is None or not getattr(service, '_transport_installed', False) for service in services):
  256. return
  257. for service in services:
  258. # start() only releases its thread; preparation and disk access happened above.
  259. service.start()
  260. from gateway.hosted_rooms_gateway_import import import_after_ready
  261. import_after_ready(serving_authorities(runner))
  262. async def stop_hosted_service(runner, timeout=5):
  263. loop = asyncio.get_running_loop()
  264. deadline, stopped = loop.time() + max(0, timeout), True
  265. for authority in all_authorities(runner):
  266. service = getattr(authority, 'hosted_room_service', None)
  267. if service is not None:
  268. result = await asyncio.to_thread(service.stop, timeout=max(0, deadline - loop.time()))
  269. stopped = result and stopped
  270. return stopped