Skip to content

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.

fix(sockets): authorize subscriptions and revalidate event delivery

Juan Denis785c5780d3ff
diff --git a/backend/app/api/runs.py b/backend/app/api/runs.py
index 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_run
from app.services.run_log_service import list_run_logs
runs_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'}), 403
after_id = request.args.get('after_id', type=int)
return jsonify({'logs': list_run_logs(run_kind, run_id, after_id=after_id)}), 200
diff --git a/backend/app/services/run_access.py b/backend/app/services/run_access.py
new file mode 100644
index 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 False
diff --git a/backend/app/sockets.py b/backend/app/sockets.py
index 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_room
from flask_jwt_extended import decode_token
-from flask import request, current_app
+from flask import request, current_app, has_app_context
import threading
import time
import queue
+import re
from app.services.system_service import SystemService
from app.services.log_service import LogService, LogStreamer
@@ -11,7 +12,26 @@ from app.services.docker_service import DockerService
from app import sockets_rooms as rooms
from 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_claims
with _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 None
def _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 payload
def _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'})
return
if 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.sid
if 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 = app
return 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 False
with _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 css
changed = 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 None
def _terminal_room(data):
from app.services.terminal_service import TerminalService
session_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'})
return
join_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 db
sid = 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'})
+ return
tail = 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.py
index 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 wire
wire.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 wire
assert ('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.py
new file mode 100644
index 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'