ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
fix(sockets): authorize subscriptions and revalidate event delivery
Juan Denis785c5780d3ff
diff --git a/backend/app/api/runs.py b/backend/app/api/runs.pyindex 6af9a45f..e53a9508 100644--- a/backend/app/api/runs.py+++ b/backend/app/api/runs.py@@ -8,7 +8,8 @@ one serves every kind stored in run_log_entries."""from flask import Blueprint, jsonify, request-from app.middleware.rbac import auth_required+from app.middleware.rbac import auth_required, get_current_user+from app.services.run_access import can_read_runfrom app.services.run_log_service import list_run_logsruns_bp = Blueprint('runs', __name__)@@ -17,5 +18,7 @@ runs_bp = Blueprint('runs', __name__)@runs_bp.route('/<run_kind>/<run_id>/logs', methods=['GET'])@auth_required()def get_run_logs(run_kind, run_id):+ if not can_read_run(get_current_user(), run_kind, run_id):+ return jsonify({'error': 'Run not found or access denied'}), 403after_id = request.args.get('after_id', type=int)return jsonify({'logs': list_run_logs(run_kind, run_id, after_id=after_id)}), 200diff --git a/backend/app/services/run_access.py b/backend/app/services/run_access.pynew file mode 100644index 00000000..92f02bfb--- /dev/null+++ b/backend/app/services/run_access.py@@ -0,0 +1,25 @@+"""Resource visibility shared by run sockets and their polling endpoint."""+++def can_read_run(user, run_kind, run_id):+ if not user or not user.is_active:+ return False+ if not isinstance(run_id, (str, int)) or isinstance(run_id, bool):+ return False+ if run_kind == 'deploy':+ from app.models.deployment_job import DeploymentJob+ from app.models import Application+ from app.services.resource_grant_service import ResourceGrantService+ job = DeploymentJob.query.populate_existing().filter_by(id=str(run_id)).first()+ if job is None:+ return False+ if job.app_id:+ application = Application.query_active().populate_existing().filter_by(id=job.app_id).first()+ return bool(application and ResourceGrantService.can_access_app(user, application))+ return user.is_admin or job.requested_by == user.id+ if run_kind == 'job':+ # The unified jobs REST surface is admin-only, regardless of owner metadata.+ from app.jobs.models import Job+ return user.is_admin and Job.query.filter_by(id=str(run_id)).first() is not None+ # Adding a new producer requires an explicit visibility policy.+ return Falsediff --git a/backend/app/sockets.py b/backend/app/sockets.pyindex 8a068540..1e99ee95 100644--- a/backend/app/sockets.py+++ b/backend/app/sockets.py@@ -1,9 +1,10 @@from flask_socketio import SocketIO, emit, join_room, leave_roomfrom flask_jwt_extended import decode_token-from flask import request, current_app+from flask import request, current_app, has_app_contextimport threadingimport timeimport queue+import refrom app.services.system_service import SystemServicefrom app.services.log_service import LogService, LogStreamer@@ -11,7 +12,26 @@ from app.services.docker_service import DockerServicefrom app import sockets_rooms as roomsfrom app.utils.background_loop import BackgroundLoop-socketio = SocketIO()++class AuthorizedSocketIO(SocketIO):+ """Recheck audience authorization before every server-side delivery.++ Background producers also use this instance, so a disabled user or a+ removed grant cannot retain access simply by leaving their socket open.+ """+ def emit(self, event, *args, **kwargs):+ if kwargs.get('namespace', '/') in (None, '/') and self.server is not None:+ application = getattr(self, '_security_app', None)+ if application is not None:+ if has_app_context():+ _prune_audience(kwargs.get('to', kwargs.get('room')))+ else:+ with application.app_context():+ _prune_audience(kwargs.get('to', kwargs.get('room')))+ return super().emit(event, *args, **kwargs)+++socketio = AuthorizedSocketIO()log_streamer = LogStreamer()# Store active metric subscriptions@@ -30,7 +50,7 @@ container_log_streams = {} # sid -> {'process': Popen, 'app_id': int, 'thread':# what role they hold — so a viewer could join a developer's live terminal# room. Keyed by request.sid; cleaned up on disconnect. Guarded by a lock# because async_mode='threading' runs handlers across worker threads.-connected_clients = {} # sid -> {'user_id': ..., 'role': ...}+connected_clients = {} # sid -> {'user_id': ..., 'role': ..., 'claims': ...}_connected_clients_lock = threading.Lock()# Roles permitted to drive/observe privileged server surfaces (remote@@ -39,20 +59,98 @@ _connected_clients_lock = threading.Lock()_PRIVILEGED_ROLES = ('admin', 'developer')-def _client_role(sid):- """Return the authenticated role for a connected socket, or None if the- socket isn't in our authenticated set (shouldn't happen post-connect)."""+def _client_user(sid):+ from app.middleware.session_auth import validate_session_claimswith _connected_clients_lock:info = connected_clients.get(sid)- return info['role'] if info else None+ if not info:+ return None+ user = validate_session_claims(info.get('claims', {}))+ # Disconnect on role changes instead of retaining previously joined rooms.+ if not user or user.role != info['role']:+ _disconnect_client(sid)+ return None+ return user+++def _disconnect_client(sid):+ with _connected_clients_lock:+ connected_clients.pop(sid, None)+ metric_subscribers.discard(sid)+ container_status_subscribers.discard(sid)+ log_streamer.stop_stream(sid)+ stop_container_log_stream(sid)+ socketio.server.disconnect(sid, namespace='/')+++def _client_role(sid):+ user = _client_user(sid)+ return user.role if user else Nonedef _client_is_privileged(sid):- """True when the connected socket belongs to an admin/developer — the- roles allowed to attach to remote terminal streams."""return _client_role(sid) in _PRIVILEGED_ROLES+def _app_visible(user, app_id):+ from app.models import Application+ from app.middleware.rbac import app_access_tier+ if not isinstance(app_id, (str, int)) or isinstance(app_id, bool):+ return False+ application = Application.query_active().populate_existing().filter_by(id=app_id).first()+ return bool(application and app_access_tier(user, application))+++def _server_visible(user, server_id):+ from app.models.server import Server+ from app.services.workspace_service import WorkspaceService+ server = Server.query.populate_existing().filter_by(id=server_id).first()+ if not server:+ return False+ return (user.is_admin or not server.workspace_id+ or WorkspaceService.get_user_role(server.workspace_id, user.id) is not None)+++def _room_allowed(user, room):+ from app.services.run_access import can_read_run+ if room == rooms.user_room(user.id):+ return True+ if room.startswith('deploy_'):+ return can_read_run(user, 'deploy', room[len('deploy_'):])+ if room.startswith('run_'):+ parts = room.split('_', 2)+ return len(parts) == 3 and can_read_run(user, parts[1], parts[2])+ match = re.fullmatch(r'logs_(\d+)', room)+ if match:+ return _app_visible(user, int(match[1]))+ match = re.fullmatch(r'server_([^_]+)_(.+)', room)+ if not match:+ return False+ server_id, channel = match.groups()+ if channel.startswith('terminal:'):+ from app.services.terminal_service import TerminalService+ session = TerminalService.get_session(channel[len('terminal:'):])+ return bool(user.role in _PRIVILEGED_ROLES and session+ and str(session['user_id']) == str(user.id)+ and str(session['server_id']) == server_id+ and _server_visible(user, server_id))+ # These are the only generic stream rooms used by the browser. Host jobs+ # may print secrets (e.g. cloudflared login URLs), so require an operator.+ return bool(re.fullmatch(r'job:[A-Za-z0-9-]+', channel)+ and user.role in _PRIVILEGED_ROLES+ and _server_visible(user, server_id))+++def _prune_audience(room=None):+ # Inspect only this delivery's audience; per-sid metrics should not scan+ # every other connection for each subscriber.+ sids = [sid for sid, _ in socketio.server.manager.get_participants('/', room)]+ for sid in sids:+ user = _client_user(sid)+ if user and room and room != sid and not _room_allowed(user, room):+ socketio.server.leave_room(sid, room, namespace='/')++# ==================== DECLARATIVE CHANNEL REGISTRY (plan 77 E2) ====================## Eight hand-rolled subscribe/unsubscribe pairs used four different registry@@ -97,9 +195,9 @@ def register_channel(name, *, room_fn=None, auth=None, on_subscribe=None,return payloaddef _subscribe(data=None):- data = data or {}+ data = data if isinstance(data, dict) else {}sid = request.sid- if sid not in connected_clients:+ if not _client_user(sid):emit('error', {'message': 'Authentication required'})returnif auth:@@ -121,7 +219,7 @@ def register_channel(name, *, room_fn=None, auth=None, on_subscribe=None,emit('subscribed', _payload(data))def _unsubscribe(data=None):- data = data or {}+ data = data if isinstance(data, dict) else {}sid = request.sidif room_fn:try:@@ -155,6 +253,7 @@ def init_socketio(app):cors_allowed_origins=app.config.get('CORS_ORIGINS', '*'),async_mode='threading')+ socketio._security_app = appreturn socketio@@ -183,18 +282,16 @@ def handle_connect(auth):emit('error', {'message': 'Invalid token'})return False- # Resolve the identity to a live, active user. decode_token only proves the- # token is well-formed and unexpired — it says nothing about whether the- # account is still allowed in.- from app.models import User- user_id = decoded.get('sub')- user = User.query.get(user_id) if user_id is not None else None- if not user or not user.is_active:- emit('error', {'message': 'Account not found or deactivated'})+ from app.middleware.session_auth import validate_session_claims+ user = validate_session_claims(decoded)+ if not user:+ emit('error', {'message': 'Invalid or revoked access token'})return Falsewith _connected_clients_lock:- connected_clients[request.sid] = {'user_id': user.id, 'role': user.role}+ connected_clients[request.sid] = {+ 'user_id': user.id, 'role': user.role, 'claims': decoded,+ }# Join a per-user room so the Notification Bus can push in-app notifications# to every tab/device this user has open.@@ -229,7 +326,8 @@ def handle_disconnect():def _metrics_tick():metrics = SystemService.get_all_metrics()- socketio.emit('metrics', metrics, room=None) # Broadcast to all+ for sid in list(metric_subscribers):+ socketio.emit('metrics', metrics, room=sid)# Ends itself when the last subscriber leaves; restarted by the next@@ -242,7 +340,7 @@ metrics_loop = BackgroundLoop(def _metrics_on_subscribe(sid, data):metric_subscribers.add(sid)- metrics_loop.start()+ metrics_loop.start(app=current_app._get_current_object())def _metrics_on_unsubscribe(sid, data):@@ -267,10 +365,15 @@ def _container_status_tick():from app.services import container_status_service as csschanged = css.get_changed_app_statuses()if changed:- socketio.emit('container_status', {- 'statuses': changed,- 'timestamp': time.time(),- }, room=None)+ for sid in list(container_status_subscribers):+ user = _client_user(sid)+ if not user:+ continue+ visible = [item for item in changed if _app_visible(user, item['app_id'])]+ if visible:+ socketio.emit('container_status', {+ 'statuses': visible, 'timestamp': time.time(),+ }, room=sid)container_status_loop = BackgroundLoop(@@ -306,13 +409,24 @@ register_channel(def _terminal_auth(sid, data):if not _client_is_privileged(sid):return 'Developer role required for terminal access'+ user = _client_user(sid)+ from app.services.terminal_service import TerminalService+ session_id = data.get('session_id')+ if not isinstance(session_id, str) or not session_id:+ return 'session_id required'+ session = TerminalService.get_session(session_id)+ if not session:+ return 'Unknown terminal session'+ if (str(session['user_id']) != str(user.id)+ or not _server_visible(user, session['server_id'])):+ return 'Terminal access denied'return Nonedef _terminal_room(data):from app.services.terminal_service import TerminalServicesession_id = data.get('session_id')- if not session_id:+ if not isinstance(session_id, str) or not session_id:raise ChannelError('session_id required')session = TerminalService.get_session(session_id)if not session:@@ -333,6 +447,11 @@ register_channel(def handle_subscribe_logs(data):"""Subscribe to real-time log streaming."""sid = request.sid+ user = _client_user(sid)+ if not user or not user.is_admin:+ emit('error', {'message': 'Admin access required for host logs'})+ return+ data = data if isinstance(data, dict) else {}filepath = data.get('path')if not filepath:@@ -370,23 +489,12 @@ def handle_unsubscribe_logs():@socketio.on('join_room')def handle_join_room(data):- """Join a specific room for targeted broadcasts.-- This is the generic join used by job-progress and cloudflared-login- streaming (rooms shaped `server_<id>_<channel>`). It is deliberately- permissive for those — the data mirrors what any authenticated user can- already pull over REST — but it must NOT become a side door into the- privileged terminal stream rooms (`server_<id>_terminal:<session>`), which- `subscribe_terminal` gates by role. Enforce that gate here too so the- generic primitive can't be used to bypass it.- """+ """Join only recognized rooms after their resource authorization check."""+ user = _client_user(request.sid)+ data = data if isinstance(data, dict) else {}room = data.get('room')- if not room or not isinstance(room, str):- emit('error', {'message': 'room required'})- return-- if rooms.is_terminal_room(room) and not _client_is_privileged(request.sid):- emit('error', {'message': 'Developer role required for terminal access'})+ if not user or not isinstance(room, str) or not _room_allowed(user, room):+ emit('error', {'message': 'Room access denied'})returnjoin_room(room)@@ -396,8 +504,9 @@ def handle_join_room(data):@socketio.on('leave_room')def handle_leave_room(data):"""Leave a specific room."""+ data = data if isinstance(data, dict) else {}room = data.get('room')- if room:+ if isinstance(room, str) and room:leave_room(room)emit('left', {'room': room})@@ -411,9 +520,16 @@ def handle_leave_room(data):# on top of the `GET /deployment-jobs/<id>/logs?after_id=` polling endpoint —# the console stays 100% functional with sockets disabled (D2).-# Deploy Console: any authenticated user may watch (mirrors the read API —-# job ids are unguessable UUIDs and the REST read endpoint exposes them the-# same way).+# Deploy visibility matches the persisted job's REST resource gate.++def _run_auth(sid, kind, run_id):+ from app.services.run_access import can_read_run+ if not run_id:+ return 'job_id required' if kind == 'deploy' else 'run_kind and run_id required'+ if not can_read_run(_client_user(sid), kind, run_id):+ return 'Run not found or access denied'+ return None+def _deploy_room(data):job_id = data.get('job_id')@@ -425,6 +541,7 @@ def _deploy_room(data):register_channel('deploy',room_fn=_deploy_room,+ auth=lambda sid, data: _run_auth(sid, 'deploy', data.get('job_id')),ack=lambda data: {'job_id': data.get('job_id')},)@@ -488,11 +605,11 @@ def _run_channel_room(data):return rooms.run_room(run_kind, run_id)-# Auth mirrors the deploy channel: any authenticated user may watch — run ids-# are unguessable and the REST twin exposes the same data the same way.+# Unknown run kinds are denied until they have an explicit visibility policy.register_channel('run',room_fn=_run_channel_room,+ auth=lambda sid, data: _run_auth(sid, data.get('run_kind'), data.get('run_id')),ack=lambda data: {'run_kind': data.get('run_kind'), 'run_id': data.get('run_id')},)@@ -520,7 +637,12 @@ def handle_subscribe_container_logs(data):from app import dbsid = request.sid+ user = _client_user(sid)+ data = data if isinstance(data, dict) else {}app_id = data.get('app_id')+ if not user or not _app_visible(user, app_id):+ emit('error', {'message': 'Application access denied'})+ returntail = data.get('tail', 100)since = data.get('since')service = data.get('service')diff --git a/backend/tests/test_channel_registry.py b/backend/tests/test_channel_registry.pyindex e18b877e..77c9a3e4 100644--- a/backend/tests/test_channel_registry.py+++ b/backend/tests/test_channel_registry.py@@ -38,7 +38,12 @@ def _run(app, handler, data=None, sid='sid-1'):def _authed(sid='sid-1', role='developer'):with sk._connected_clients_lock:- sk.connected_clients[sid] = {'user_id': 1, 'role': role}+ from flask_jwt_extended import create_access_token, decode_token+ user = make_user(db, role=role)+ sk.connected_clients[sid] = {+ 'user_id': user.id, 'role': role,+ 'claims': decode_token(create_access_token(identity=user.id)),+ }def test_registered_channels_exist(app):@@ -72,6 +77,9 @@ def test_deploy_requires_job_id_then_joins_room(app, wire):assert ('error', {'message': 'job_id required'}) in wirewire.clear()+ from app.models.deployment_job import DeploymentJob+ db.session.add(DeploymentJob(id='job-1', kind='test', requested_by=sk.connected_clients['sid-1']['user_id']))+ db.session.commit()_run(app, sk.CHANNELS['deploy']['subscribe'], {'job_id': 'job-1'})assert ('__join__', 'deploy_job-1') in wireassert ('subscribed', {'channel': 'deploy', 'job_id': 'job-1'}) in wire@@ -99,7 +107,7 @@ def test_terminal_unsubscribe_does_not_ack(app, wire):def test_generic_join_room_still_gates_terminal_rooms(app, wire):_authed(role='viewer')_run(app, sk.handle_join_room, {'room': 'server_s1_terminal:sess'})- assert wire == [('error', {'message': 'Developer role required for terminal access'})]+ assert wire == [('error', {'message': 'Room access denied'})]def test_raw_subscribe_handlers_are_frozen():diff --git a/backend/tests/test_socket_security.py b/backend/tests/test_socket_security.pynew file mode 100644index 00000000..4788eb8f--- /dev/null+++ b/backend/tests/test_socket_security.py@@ -0,0 +1,230 @@+"""Socket authorization must hold both when joining and during delivery."""+import pytest+from flask_jwt_extended import create_access_token, create_refresh_token++from app import sockets as sk+from app.models.deployment_job import DeploymentJob+from factories import make_user, make_application, headers_for+++def clients(app):+ opened = []++ def connect(user=None, token=None):+ client = sk.socketio.test_client(app, auth={+ 'token': token or create_access_token(identity=user.id),+ })+ opened.append(client)+ if client.is_connected():+ client.get_received()+ return client++ yield connect+ for client in opened:+ if client.is_connected():+ client.disconnect()++[email protected]('kind', ['pending', 'refresh', 'no-expiry'])+def test_socket_rejects_non_session_tokens(db_session, clients, kind):+ user = make_user(db_session, role='admin')+ if kind == 'pending':+ token = create_access_token(identity=user.id, additional_claims={'2fa_pending': True})+ elif kind == 'refresh':+ token = create_refresh_token(identity=user.id)+ else:+ token = create_access_token(identity=user.id, expires_delta=False)+ assert not clients(token=token).is_connected()+++def test_other_user_room_cannot_receive_notifications(db_session, clients):+ user = make_user(db_session, role='viewer')+ other = make_user(db_session)+ sock = clients(user)+ sock.emit('join_room', {'room': sk.rooms.user_room(other.id)})+ assert any(e['name'] == 'error' for e in sock.get_received())+ sk.socketio.emit('private', {'secret': 'foreign'}, room=sk.rooms.user_room(other.id))+ assert sock.get_received() == []+ sk.socketio.emit('private', {'secret': 'own'}, room=sk.rooms.user_room(user.id))+ assert sock.get_received()[0]['name'] == 'private'+++def test_app_and_deploy_rooms_follow_resource_access(db_session, clients):+ user = make_user(db_session, role='viewer')+ own = make_application(db_session, user_id=user.id)+ foreign = make_application(db_session)+ for application in (own, foreign):+ db_session.session.add(DeploymentJob(id=f'd-{application.id}', kind='test', app_id=application.id))+ db_session.session.commit()+ sock = clients(user)+ for application, allowed in ((own, True), (foreign, False)):+ job_id = f'd-{application.id}'+ for event, data in [+ ('join_room', {'room': sk.rooms.app_logs_room(application.id)}),+ ('join_room', {'room': sk.rooms.deploy_room(job_id)}),+ ('join_room', {'room': sk.rooms.run_room('deploy', job_id)}),+ ('subscribe_deploy', {'job_id': job_id}),+ ('subscribe_run', {'run_kind': 'deploy', 'run_id': job_id}),+ ]:+ sock.emit(event, data)+ events = sock.get_received()+ assert any(e['name'] in ('joined', 'subscribed') for e in events) is allowed+ assert any(e['name'] == 'error' for e in events) is not allowed+ if event == 'subscribe_deploy':+ room = sk.rooms.deploy_room(job_id)+ elif event == 'subscribe_run':+ room = sk.rooms.run_room('deploy', job_id)+ else:+ room = data['room']+ sk.socketio.emit('delivery-proof', {'ok': True}, room=room)+ assert any(e['name'] == 'delivery-proof' for e in sock.get_received()) is allowed+++def test_requester_can_watch_appless_deploy_but_not_missing_or_unknown_runs(db_session, clients):+ user = make_user(db_session, role='developer')+ db_session.session.add(DeploymentJob(id='own', kind='test', requested_by=user.id))+ db_session.session.commit()+ sock = clients(user)+ sock.emit('subscribe_deploy', {'job_id': 'own'})+ assert sock.get_received()[0]['name'] == 'subscribed'+ for kind, rid in [('deploy', 'missing'), ('unknown', 'own'), ('job', 'own')]:+ sock.emit('subscribe_run', {'run_kind': kind, 'run_id': rid})+ assert sock.get_received()[0]['name'] == 'error'+++def test_host_and_foreign_container_logs_denied_before_io(db_session, clients, monkeypatch):+ user = make_user(db_session, role='viewer')+ foreign = make_application(db_session)+ monkeypatch.setattr(sk.log_streamer, 'start_stream', lambda *a: pytest.fail('host I/O reached'))+ monkeypatch.setattr(sk.DockerService, 'get_all_app_containers', lambda *a: pytest.fail('Docker reached'))+ sock = clients(user)+ for event, data in [('subscribe_logs', {'path': '/var/log/auth.log'}),+ ('subscribe_container_logs', {'app_id': foreign.id})]:+ sock.emit(event, data)+ assert sock.get_received()[0]['name'] == 'error'+++def test_server_job_and_terminal_require_operator_and_session_owner(db_session, clients, monkeypatch):+ from app.models.server import Server+ from app.services.terminal_service import TerminalService+ server = Server(name='test', id='server-1')+ db_session.session.add(server)+ operator = make_user(db_session, role='developer')+ viewer = make_user(db_session, role='viewer')+ other = make_user(db_session, role='developer')+ monkeypatch.setattr(TerminalService, 'get_session', lambda sid: {+ 'server_id': server.id, 'user_id': operator.id,+ } if sid == 'session-1' else None)+ for user in (operator, viewer, other):+ sock = clients(user)+ sock.emit('join_room', {'room': sk.rooms.server_channel_room(server.id, 'job:job-1')})+ assert sock.get_received()[0]['name'] == ('error' if user == viewer else 'joined')+ sk.socketio.emit('server_stream', {'channel': 'job:job-1'},+ room=sk.rooms.server_channel_room(server.id, 'job:job-1'))+ assert any(e['name'] == 'server_stream' for e in sock.get_received()) is (user != viewer)+ for event, data in [+ ('subscribe_terminal', {'session_id': 'session-1'}),+ ('join_room', {'room': sk.rooms.server_terminal_room(server.id, 'session-1')}),+ ]:+ sock.emit(event, data)+ assert (sock.get_received()[0]['name'] != 'error') is (user == operator)+ sk.socketio.emit('server_stream', {'channel': 'terminal:session-1'},+ room=sk.rooms.server_terminal_room(server.id, 'session-1'))+ assert any(e['name'] == 'server_stream' for e in sock.get_received()) is (user == operator)+ sock.emit('join_room', {'room': 'server_missing_job:job-1'})+ assert sock.get_received()[0]['name'] == 'error'++[email protected]('change', ['disabled', 'role', 'revoke'])+def test_open_socket_is_revoked_before_next_delivery(db_session, clients, change):+ user = make_user(db_session, role='developer')+ sock = clients(user)+ if change == 'disabled':+ user.is_active = False+ elif change == 'role':+ user.role = 'viewer'+ else:+ user.revoke_sessions()+ db_session.session.commit()+ sk.socketio.emit('private', {'secret': 'must not arrive'}, room=sk.rooms.user_room(user.id))+ assert not sock.is_connected()+++def test_removed_app_grant_stops_already_joined_stream(db_session, clients):+ from app.models.workspace import ResourceGrant+ user = make_user(db_session, role='viewer')+ application = make_application(db_session)+ grant = ResourceGrant(user_id=user.id, resource_type='application', resource_id=application.id, role='viewer')+ db_session.session.add(grant)+ db_session.session.commit()+ sock = clients(user)+ sock.emit('join_room', {'room': sk.rooms.app_logs_room(application.id)})+ assert sock.get_received()[0]['name'] == 'joined'+ db_session.session.delete(grant)+ db_session.session.commit()+ sk.emit_container_log(application.id, 'private')+ assert sock.get_received() == []+++def test_status_broadcast_is_scoped_to_subscribers_and_visible_apps(db_session, clients, monkeypatch):+ from app.services import container_status_service as css+ user = make_user(db_session, role='viewer')+ own = make_application(db_session, user_id=user.id)+ foreign = make_application(db_session)+ sock, idle = clients(user), clients(user)+ monkeypatch.setattr(sk.container_status_loop, 'start', lambda **kwargs: None)+ monkeypatch.setattr(css, 'get_changed_app_statuses', lambda: [+ {'app_id': own.id, 'status': 'running'},+ {'app_id': foreign.id, 'status': 'running'},+ ])+ sock.emit('subscribe_container_status')+ sock.get_received()+ sk._container_status_tick()+ statuses = sock.get_received()[0]['args'][0]['statuses']+ assert [row['app_id'] for row in statuses] == [own.id]+ assert idle.get_received() == []+++def test_metrics_only_reach_subscribers(db_session, clients, monkeypatch):+ user = make_user(db_session)+ sock, idle = clients(user), clients(user)+ monkeypatch.setattr(sk.metrics_loop, 'start', lambda **kwargs: None)+ monkeypatch.setattr(sk.SystemService, 'get_all_metrics', lambda: {'cpu': 1})+ sock.emit('subscribe_metrics')+ sock.get_received()+ sk._metrics_tick()+ assert sock.get_received()[0]['name'] == 'metrics'+ assert idle.get_received() == []+++def test_run_polling_cannot_bypass_socket_gate(client, db_session):+ user = make_user(db_session, role='viewer')+ foreign = make_application(db_session)+ db_session.session.add(DeploymentJob(id='foreign', kind='test', app_id=foreign.id))+ db_session.session.commit()+ assert client.get('/api/v1/runs/deploy/foreign/logs', headers=headers_for(user)).status_code == 403+++def test_logout_revokes_existing_socket(client, db_session, clients):+ user = make_user(db_session)+ token = create_access_token(identity=user.id)+ sock = clients(token=token)+ response = client.post('/api/v1/auth/logout', headers={'Authorization': f'Bearer {token}'})+ assert response.status_code == 200+ sk.socketio.emit('private', {'secret': 'must not arrive'}, room=sk.rooms.user_room(user.id))+ assert not sock.is_connected()+++def test_operator_cannot_join_other_workspace_server(db_session, clients):+ from app.models.server import Server+ from app.models.workspace import Workspace+ workspace = Workspace(name='Private', slug='private')+ db_session.session.add(workspace)+ db_session.session.flush()+ server = Server(id='private-server', name='Private', workspace_id=workspace.id)+ db_session.session.add(server)+ user = make_user(db_session, role='developer')+ sock = clients(user)+ sock.emit('join_room', {'room': sk.rooms.server_channel_room(server.id, 'job:job-1')})+ assert sock.get_received()[0]['name'] == 'error'