diff --git a/Core/Api/CompositeEndpoints.cs b/Core/Api/CompositeEndpoints.cs
new file mode 100644
index 0000000..f4fa672
--- /dev/null
+++ b/Core/Api/CompositeEndpoints.cs
@@ -0,0 +1,92 @@
+using Microsoft.AspNetCore.Http.HttpResults;
+using OpenStreamMS.Services.Mosaic;
+using OpenStreamMS.Services.Seats;
+
+namespace OpenStreamMS.Core.Api;
+
+/// Hueco de una sesión compuesta en la API.
+/// Sesión RDP del hueco.
+/// Parte de la pantalla: Left, Right, Top, Bottom, TopLeft, TopRight, BottomLeft o BottomRight.
+public record CompositeSlotRequest(Guid Session, SeatScreenArea Area);
+
+/// Crear o editar una sesión compuesta.
+/// Nombre (el que se ve en Moonlight).
+/// De 2 a 4 huecos sin pisarse, en orden: el mando N va al hueco N.
+/// Sesión del teclado, el ratón y el audio; null = la del primer hueco.
+/// Ancho del stream.
+/// Alto del stream.
+/// Fps del stream.
+/// Arrancarla con el servicio.
+/// Puerto base de su Sunshine; 0 o ausente = el primero libre.
+/// Protocolos de su Sunshine.
+public record CompositeRequest(
+ string Name,
+ IReadOnlyList Slots,
+ Guid? Input = null,
+ int Width = 1920,
+ int Height = 1080,
+ int FrameRate = 60,
+ bool Enabled = false,
+ int SunshineStreamPort = 0,
+ StreamProtocol StreamProtocol = StreamProtocol.Both);
+
+/// Plantilla de huecos que ofrece el panel.
+public record CompositeTemplate(string Id, IReadOnlyList Areas);
+
+///
+/// API de las sesiones compuestas. Crear y editar van aquí; arrancar, parar, borrar, logs y
+/// emparejamiento son los de cualquier sesión (/api/sessions/{id}/...).
+///
+public static class CompositeEndpoints
+{
+ public static IEndpointRouteBuilder MapCompositeApi(this IEndpointRouteBuilder app)
+ {
+ var group = app.MapGroup("/api/composites").WithTags("Composite sessions");
+
+ group.MapGet("/templates", () => TypedResults.Ok(
+ MosaicLayout.Templates.Select(t => new CompositeTemplate(t.Key, t.Value))))
+ .WithName("GetCompositeTemplates")
+ .WithSummary("Plantillas de huecos de las sesiones compuestas");
+
+ group.MapPost("/", Create)
+ .WithName("CreateComposite")
+ .WithSummary("Crear una sesión compuesta")
+ .WithDescription("""
+ Junta en un stream propio las pantallas de 2 a 4 sesiones RDP con captura RemoteIdd,
+ cada una en su hueco. Tiene su propio Sunshine (puertos, emparejamiento y nombre en
+ Moonlight). Al arrancarla se arrancan las sesiones paradas.
+ """);
+
+ group.MapPut("/{id:guid}", Update)
+ .WithName("UpdateComposite")
+ .WithSummary("Editar una sesión compuesta parada");
+
+ return app;
+ }
+
+ private static CompositeDefinition ToDefinition(CompositeRequest req) => new(
+ req.Name ?? "",
+ (req.Slots ?? []).Select(s => new CompositeSlot(s.Session, s.Area)).ToList(),
+ req.Input, req.Width, req.Height, req.FrameRate, req.Enabled,
+ req.SunshineStreamPort, req.StreamProtocol);
+
+ private static Results, BadRequest, NotFound> Create(
+ CompositeRequest req, StreamSessionService svc)
+ {
+ try
+ {
+ var s = svc.CreateComposite(ToDefinition(req));
+ return TypedResults.Created($"/api/sessions/{s.Id}", SessionEndpoints.ToResponse(s));
+ }
+ catch (KeyNotFoundException) { return TypedResults.NotFound(); }
+ catch (InvalidOperationException ex) { return TypedResults.BadRequest(ex.Message); }
+ }
+
+ private static Results, BadRequest, NotFound> Update(
+ Guid id, CompositeRequest req, StreamSessionService svc)
+ {
+ try { return TypedResults.Ok(SessionEndpoints.ToResponse(svc.UpdateComposite(id, ToDefinition(req)))); }
+ catch (KeyNotFoundException) { return TypedResults.NotFound(); }
+ catch (InvalidOperationException ex) { return TypedResults.BadRequest(ex.Message); }
+ }
+}
diff --git a/Core/Api/MosaicEndpoints.cs b/Core/Api/MosaicEndpoints.cs
deleted file mode 100644
index da6e281..0000000
--- a/Core/Api/MosaicEndpoints.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-using OpenStreamMS.Services.Mosaic;
-
-namespace OpenStreamMS.Core.Api;
-
-/// Sesión de OpenStreamMS.
-/// Nombre de la sesión.
-/// Parte de la cuadrícula que ocupa (Full, Left, Right, TopLeft…).
-public record MosaicMemberDto(Guid Id, string Name, string Area);
-
-/// Sesión anfitriona (la que se retransmite).
-/// Por orden de llegada; la primera es la anfitriona. El mando N va a la sesión N.
-/// Con dos sesiones, una encima de otra en vez de una al lado de otra.
-public record MosaicDto(Guid Host, List Members, bool Stacked);
-
-/// true: una encima de otra (arriba/abajo); false: una al lado de otra (izquierda/derecha).
-public record MosaicLayoutRequest(bool Stacked);
-
-///
-/// Endpoints REST del mosaico (ver ). Mismo estilo que .
-///
-public static class MosaicEndpoints
-{
- public static IEndpointRouteBuilder MapMosaicApi(this IEndpointRouteBuilder app)
- {
- var group = app.MapGroup("/api/sessions/{id:guid}/mosaic").WithTags("Mosaic");
-
- group.MapGet("/", (Guid id, MosaicService mosaic, StreamSessionService sessions) =>
- sessions.Get(id) is null ? Results.NotFound() : Results.Ok(ToDto(id, mosaic, sessions)))
- .WithName("GetMosaic")
- .WithSummary("Mosaico de una sesión anfitriona")
- .WithDescription("Sesiones que comparten el stream de la anfitriona, por orden de llegada y con su parte de la pantalla. " +
- "Sin mosaico, la lista solo tiene la anfitriona a pantalla entera.");
-
- group.MapPost("/{guestId:guid}", async (Guid id, Guid guestId, MosaicService mosaic, StreamSessionService sessions, CancellationToken ct) =>
- await Action(() => mosaic.JoinAsync(id, guestId, ct), id, mosaic, sessions))
- .WithName("JoinMosaic")
- .WithSummary("Unir una sesión al mosaico")
- .WithDescription("""
- Une la sesión guestId al stream de la sesión anfitriona {id} (hasta cuatro en total), en la
- siguiente parte libre: 2 sesiones en mitades, 3 o 4 en cuartos. La invitada se arranca si
- hace falta y su Sunshine queda en pausa. Las sesiones se reconectan al tamaño de su parte
- (~1-2 s cada una). Requiere captura RemoteIdd y un cliente conectado a la anfitriona.
- """);
-
- group.MapDelete("/{memberId:guid}", async (Guid id, Guid memberId, MosaicService mosaic, StreamSessionService sessions, CancellationToken ct) =>
- await Action(() => mosaic.LeaveAsync(id, memberId, ct), id, mosaic, sessions))
- .WithName("LeaveMosaic")
- .WithSummary("Sacar una sesión del mosaico")
- .WithDescription("Saca la sesión del mosaico: vuelve a su resolución y a servirse por su Sunshine. " +
- "Sacar a la anfitriona deshace el mosaico.");
-
- group.MapPut("/layout", async (Guid id, MosaicLayoutRequest req, MosaicService mosaic, StreamSessionService sessions, CancellationToken ct) =>
- await Action(() => mosaic.SetStackedAsync(id, req.Stacked, ct), id, mosaic, sessions))
- .WithName("SetMosaicLayout")
- .WithSummary("Disposición con dos sesiones")
- .WithDescription("Con dos sesiones, una al lado de otra (stacked: false) o una encima de otra (stacked: true). " +
- "Las dos se reconectan al tamaño de su nueva mitad. Con tres o cuatro se recuerda para cuando vuelvan a ser dos.");
-
- return app;
- }
-
- private static async Task Action(Func op, Guid host, MosaicService mosaic, StreamSessionService sessions)
- {
- try
- {
- await op();
- return Results.Ok(ToDto(host, mosaic, sessions));
- }
- catch (KeyNotFoundException) { return Results.NotFound(); }
- catch (InvalidOperationException ex) { return Results.BadRequest(ex.Message); }
- }
-
- private static MosaicDto ToDto(Guid host, MosaicService mosaic, StreamSessionService sessions)
- {
- var ids = mosaic.Members(host);
- if (ids.Count == 0) ids = [host];
- var areas = MosaicLayout.Areas(ids.Count, mosaic.IsStacked(host));
- return new MosaicDto(host, ids.Select((id, i) =>
- new MosaicMemberDto(id, sessions.Get(id)?.Name ?? "", areas[i].ToString())).ToList(), mosaic.IsStacked(host));
- }
-}
diff --git a/Core/Api/SessionEndpoints.cs b/Core/Api/SessionEndpoints.cs
index 6f72b49..35c753e 100644
--- a/Core/Api/SessionEndpoints.cs
+++ b/Core/Api/SessionEndpoints.cs
@@ -257,14 +257,12 @@ public record SessionResponse(
RdpCompositionMode RdpComposition = RdpCompositionMode.Smooth,
/// Paso del arranque en el que falló (user, rdp, profile, unlock, sunshine); null si no hay error.
string? FailedPhase = null,
- /// Anfitriona del mosaico en el que está la sesión (la propia si es la anfitriona); null fuera de un mosaico.
- Guid? MosaicHost = null,
- /// Posición en el mosaico por orden de llegada (0 = anfitriona; el mando N va a la N).
- int? MosaicIndex = null,
- /// Sesiones en el mosaico de la anfitriona (solo en la anfitriona).
- int? MosaicCount = null,
- /// Solo en la anfitriona: con dos sesiones, una encima de otra en vez de una al lado de otra.
- bool MosaicStacked = false
+ /// Solo en una sesión compuesta: sus huecos en orden (el mando N va al hueco N).
+ IReadOnlyList? Composite = null,
+ /// Solo en una sesión compuesta: sesión del teclado, el ratón y el audio.
+ Guid? CompositeInput = null,
+ /// En un miembro: la sesión compuesta en marcha que lo usa; null si ninguna.
+ Guid? CompositeOf = null
);
/// Usuario dedicado o perfil osms-* que ya no usa ninguna sesión.
@@ -1013,5 +1011,5 @@ static async Task UnpairAllClients(
StreamSessionService.SteamLoginState(s),
s.RdpDisplayScale, s.RdpComposition,
s.ErrorMessage is null ? null : s.FailedPhase,
- s.MosaicHost, s.MosaicIndex, s.MosaicCount, s.MosaicStacked);
+ s.Composite, s.CompositeInput, s.CompositeOf);
}
diff --git a/Core/Api/StreamSession.cs b/Core/Api/StreamSession.cs
index 83afed3..104bfa1 100644
--- a/Core/Api/StreamSession.cs
+++ b/Core/Api/StreamSession.cs
@@ -236,14 +236,24 @@ public string GetIsolatedUser() =>
public int? ClientsMoonlight { get; set; }
public int? ClientsWebRtc { get; set; }
///
- /// Sesión anfitriona del mosaico en el que está esta sesión (la propia si es la anfitriona);
- /// null fuera de un mosaico. Lo mantiene . No se persiste.
- ///
- public Guid? MosaicHost { get; set; }
- /// Posición en el mosaico por orden de llegada (0 = anfitriona; el mando N va a la N). No se persiste.
- public int? MosaicIndex { get; set; }
- /// Sesiones en el mosaico, solo en la anfitriona. No se persiste.
- public int? MosaicCount { get; set; }
- /// Solo en la anfitriona: con dos sesiones, una encima de otra. No se persiste.
- public bool MosaicStacked { get; set; }
+ /// Sesión compuesta: en vez de una sesión de Windows propia, junta en un stream las pantallas
+ /// de 2 a 4 sesiones RDP, cada una en su hueco (; ver
+ /// StreamSessionService.Composite.cs). Tiene su propio Sunshine (puertos, emparejamiento,
+ /// nombre en Moonlight). Null en las sesiones normales.
+ ///
+ public List? Composite { get; set; }
+ /// Solo en una compuesta: sesión que recibe teclado y ratón y de la que sale el audio.
+ public Guid? CompositeInput { get; set; }
+ /// True si es una sesión compuesta.
+ public bool IsComposite => Composite is not null;
+ ///
+ /// En un miembro: la sesión compuesta en marcha que lo está usando (su Sunshine propio queda
+ /// en pausa). Null si no está en ninguna. No se persiste.
+ ///
+ public Guid? CompositeOf { get; set; }
}
+
+/// Hueco de una sesión compuesta: qué sesión se ve en qué parte de la pantalla.
+/// Sesión RDP que se ve en el hueco.
+/// Parte de la pantalla (las de la pantalla dividida de los puestos).
+public sealed record CompositeSlot(Guid Session, OpenStreamMS.Services.Seats.SeatScreenArea Area);
diff --git a/Core/Api/StreamSessionService.Composite.cs b/Core/Api/StreamSessionService.Composite.cs
new file mode 100644
index 0000000..2d0c959
--- /dev/null
+++ b/Core/Api/StreamSessionService.Composite.cs
@@ -0,0 +1,375 @@
+using OpenStreamMS.Core.Helpers;
+using OpenStreamMS.Services;
+using OpenStreamMS.Services.Localization;
+using OpenStreamMS.Services.Mosaic;
+using OpenStreamMS.Services.Seats;
+using System.Collections.Concurrent;
+
+namespace OpenStreamMS.Core.Api;
+
+/// Lo que define una sesión compuesta (crear y editar).
+/// Nombre de la compuesta (y el que publica su Sunshine).
+/// Huecos con su sesión, en orden: el mando N va al hueco N.
+/// Sesión que recibe teclado y ratón y de la que sale el audio; null = la del primer hueco.
+/// Ancho del lienzo (la resolución que recibe el cliente).
+/// Alto del lienzo.
+/// Fps del stream y de las sesiones mientras están en la compuesta.
+/// Arrancarla con el servicio.
+/// Puerto base de su Sunshine; 0 = el primero libre.
+/// Protocolos de su Sunshine.
+public sealed record CompositeDefinition(
+ string Name, IReadOnlyList Slots, Guid? Input,
+ int Width, int Height, int FrameRate, bool Enabled,
+ int StreamPort = 0, StreamProtocol Protocol = StreamProtocol.Both);
+
+///
+/// Sesiones compuestas: una sesión sin Windows propio que junta en un stream las pantallas de 2 a
+/// 4 sesiones RDP, cada una en su hueco.
+///
+/// Al arrancarla se arrancan las sesiones paradas, se pone en pausa el Sunshine de cada una
+/// (nadie más lee su pantalla), se reconectan al tamaño de su hueco y se lanza el Sunshine propio de
+/// la compuesta en la sesión de Windows de , que compone
+/// todas con osms-mosaic.txt (). Por eso teclado, ratón y audio
+/// son los de esa sesión.
+/// Al pararla, cada sesión vuelve a su tamaño y a su Sunshine, y se paran las que arrancó ella.
+/// Mandos: el mando N que crea su Sunshine va a la sesión del hueco N ().
+///
+/// Las sesiones siguen siendo normales: pueden estar en varias compuestas, pero solo en una en marcha.
+///
+public partial class StreamSessionService
+{
+ private static readonly TimeSpan CompositeMemberTimeout = TimeSpan.FromSeconds(120);
+
+ /// Miembros que arrancó cada compuesta en marcha: se paran al pararla.
+ private readonly ConcurrentDictionary> _compositeStarted = new();
+ /// Tamaño RDP que tiene ahora cada miembro de cada compuesta, para reconectar solo lo que cambia.
+ private readonly ConcurrentDictionary> _compositeApplied = new();
+ private int _compositeGeneration;
+
+ /// Sube cada vez que una compuesta arranca, para o cambia la sesión de Windows de un miembro.
+ public int CompositeGeneration => Volatile.Read(ref _compositeGeneration);
+
+ // ── Crear y editar ───────────────────────────────────────────────────────
+
+ public StreamSession CreateComposite(CompositeDefinition def)
+ {
+ var (slots, input) = ValidateComposite(null, def);
+ var suggested = SunshinePorts.Suggest(_sessions.Values.ToList());
+ var session = new StreamSession
+ {
+ Name = def.Name.Trim(),
+ Composite = slots,
+ CompositeInput = input,
+ SunshineExePath = ResolveExePath(null),
+ RdpWidth = def.Width > 0 ? def.Width : 1920,
+ RdpHeight = def.Height > 0 ? def.Height : 1080,
+ RdpFrameRate = NormalizeRdpFrameRate(def.FrameRate),
+ Enabled = def.Enabled,
+ Capture = "remoteidd",
+ StreamProtocol = def.Protocol,
+ SunshineStreamPort = def.StreamPort > 0 ? def.StreamPort : suggested.SunshineStreamPort,
+ WebRtcPort = suggested.WebRtcPort,
+ WebRtcMediaPortMin = suggested.WebRtcMediaPortMin,
+ WebRtcMediaPortMax = suggested.WebRtcMediaPortMax,
+ };
+ EnsurePortsAvailable(session, _sessions.Values);
+ _sessions[session.Id] = session;
+ Logger.Log($"[SessionService] Sesión compuesta creada: '{session.Name}' ({session.Id}) con " +
+ string.Join(", ", slots.Select(s => $"{_sessions[s.Session].Name} ({s.Area})")));
+ SaveSessions();
+ return session;
+ }
+
+ /// Cambia una compuesta parada (en marcha habría que recolocar sesiones con clientes conectados).
+ public StreamSession UpdateComposite(Guid id, CompositeDefinition def)
+ {
+ var session = RequireSession(id);
+ if (!session.IsComposite) throw new KeyNotFoundException();
+ if (session.State is SessionState.Starting or SessionState.Running or SessionState.Stopping)
+ throw new InvalidOperationException(RequestCulture.T("error.stopSession"));
+
+ var (slots, input) = ValidateComposite(id, def);
+ session.Name = def.Name.Trim();
+ session.Composite = slots;
+ session.CompositeInput = input;
+ session.RdpWidth = def.Width > 0 ? def.Width : session.RdpWidth;
+ session.RdpHeight = def.Height > 0 ? def.Height : session.RdpHeight;
+ session.RdpFrameRate = NormalizeRdpFrameRate(def.FrameRate);
+ session.Enabled = def.Enabled;
+ session.StreamProtocol = def.Protocol;
+ if (def.StreamPort > 0) session.SunshineStreamPort = def.StreamPort;
+ EnsurePortsAvailable(session, _sessions.Values);
+ _sunshine.TryRemove(id, out _); // el siguiente arranque escribe la configuración nueva
+ Logger.Log($"[{session.Name}] Sesión compuesta modificada.", id);
+ SaveSessions();
+ return session;
+ }
+
+ private (List Slots, Guid Input) ValidateComposite(Guid? selfId, CompositeDefinition def)
+ {
+ if (string.IsNullOrWhiteSpace(def.Name))
+ throw new InvalidOperationException(RequestCulture.T("error.compositeName"));
+ var slots = def.Slots.Where(s => s.Session != Guid.Empty).ToList();
+ if (slots.Count < MosaicLayout.MinMembers || slots.Count > MosaicLayout.MaxMembers)
+ throw new InvalidOperationException(RequestCulture.T("error.compositeCount"));
+ if (slots.Select(s => s.Session).Distinct().Count() != slots.Count)
+ throw new InvalidOperationException(RequestCulture.T("error.compositeRepeated"));
+ if (!MosaicLayout.Disjoint(slots.Select(s => s.Area)))
+ throw new InvalidOperationException(RequestCulture.T("error.compositeOverlap"));
+
+ foreach (var slot in slots)
+ {
+ if (!_sessions.TryGetValue(slot.Session, out var member) || member.Id == selfId)
+ throw new KeyNotFoundException();
+ if (member.Local || member.IsComposite || !WantsRemoteIdd(member))
+ throw new InvalidOperationException(RequestCulture.T("error.compositeMember", member.Name));
+ }
+ var input = def.Input is { } i && slots.Any(s => s.Session == i) ? i : slots[0].Session;
+ return (slots, input);
+ }
+
+ /// Compuestas que usan la sesión .
+ private IEnumerable CompositesUsing(Guid id) =>
+ _sessions.Values.Where(s => s.Composite?.Any(slot => slot.Session == id) == true);
+
+ // ── Arrancar y parar ─────────────────────────────────────────────────────
+
+ /// Arranque de una compuesta (desde ). Si falla, deja los miembros como estaban.
+ private void StartComposite(StreamSession c, int generation)
+ {
+ var slots = c.Composite!;
+ var members = slots.Select(s => _sessions.TryGetValue(s.Session, out var m) ? m
+ : throw new InvalidOperationException(RequestCulture.T("error.compositeMissing")))
+ .ToList();
+
+ // Que ninguna esté ya ocupada: en otra compuesta, en un puesto en exclusiva o con su propio cliente.
+ foreach (var m in members)
+ {
+ if (m.CompositeOf is { } other && other != c.Id && _sessions.TryGetValue(other, out var o))
+ throw new InvalidOperationException(RequestCulture.T("error.compositeBusy", m.Name, o.Name));
+ if (IsSunshinePaused(m.Id) && m.CompositeOf != c.Id)
+ throw new InvalidOperationException(RequestCulture.T("error.compositeSeat", m.Name));
+ if (m.ClientsMoonlight + m.ClientsWebRtc is > 0)
+ throw new InvalidOperationException(RequestCulture.T("error.compositeStreaming", m.Name));
+ }
+
+ var started = _compositeStarted.GetOrAdd(c.Id, _ => []);
+ var applied = _compositeApplied.GetOrAdd(c.Id, _ => new());
+ try
+ {
+ c.StartPhase = "members";
+ foreach (var m in members.Where(m => m.State is not (SessionState.Running or SessionState.Starting)))
+ {
+ Logger.Log($"[{c.Name}] Arrancando '{m.Name}' para la sesión compuesta…", c.Id);
+ Start(m.Id);
+ lock (started) started.Add(m.Id);
+ }
+ foreach (var m in members) WaitCompositeMember(c, m);
+
+ foreach (var m in members)
+ {
+ PauseSunshine(m.Id, $"sesión compuesta '{c.Name}'");
+ m.CompositeOf = c.Id;
+ applied[m.Id] = (m.RdpWidth, m.RdpHeight);
+ }
+ Interlocked.Increment(ref _compositeGeneration);
+
+ c.StartPhase = "layout";
+ ApplyComposite(c);
+
+ var owner = _sessions[c.CompositeInput ?? slots[0].Session];
+ c.RdpSessionId = owner.RdpSessionId;
+ c.StartPhase = "sunshine";
+ var user = ResolveUser(owner);
+ EnsureSunshineInstance(c, user.Domain, user.Username);
+ var result = GetOrCreateSunshineManager(c).EnsureRunning(c.RdpSessionId);
+ c.SunshinePid = result.Pid;
+ if (result.Status == Services.Sunshine.SunshineRunStatus.LaunchFailed)
+ throw new Exception(result.Message ?? RequestCulture.T("error.request"));
+
+ bool running;
+ lock (c.LifecycleLock)
+ {
+ // Detenida o sustituida por otra orden mientras arrancaba.
+ running = StartStillWanted(c, generation);
+ if (running)
+ {
+ c.State = SessionState.Running;
+ c.StartedAt = DateTime.UtcNow;
+ }
+ }
+ if (!running)
+ {
+ Logger.Log($"[{c.Name}] Inicio abortado (sesión detenida mientras arrancaba).", c.Id);
+ return;
+ }
+ Logger.Log($"[{c.Name}] Sesión compuesta activa: {string.Join(", ", members.Select(m => m.Name))}; " +
+ $"teclado, ratón y audio de '{owner.Name}' (sesión de Windows {c.RdpSessionId}).", c.Id);
+ }
+ catch
+ {
+ ReleaseComposite(c);
+ throw;
+ }
+ }
+
+ private void WaitCompositeMember(StreamSession c, StreamSession m)
+ {
+ var deadline = DateTime.UtcNow + CompositeMemberTimeout;
+ while (m.State != SessionState.Running || m.RdpSessionId == 0)
+ {
+ if (c.State != SessionState.Starting)
+ throw new InvalidOperationException(RequestCulture.T("error.request"));
+ if (m.State is SessionState.Error or SessionState.Stopped || DateTime.UtcNow > deadline)
+ throw new InvalidOperationException(RequestCulture.T("error.compositeMemberStart", m.Name));
+ Thread.Sleep(500);
+ }
+ }
+
+ ///
+ /// Deja cada miembro en marcha en su hueco: reconecta los que cambian de tamaño y escribe el
+ /// fichero de Sunshine (después, porque una reconexión puede cambiar la sesión de Windows).
+ ///
+ private void ApplyComposite(StreamSession c)
+ {
+ var applied = _compositeApplied.GetOrAdd(c.Id, _ => new());
+ foreach (var slot in c.Composite!)
+ {
+ if (!_sessions.TryGetValue(slot.Session, out var m) || m.State != SessionState.Running || m.RdpSessionId == 0)
+ continue;
+ var target = MosaicLayout.PartSize(slot.Area, c.RdpWidth, c.RdpHeight);
+ if (applied.GetValueOrDefault(m.Id) == target) continue;
+ ReconnectRdp(m.Id, target.Width, target.Height, c.RdpFrameRate);
+ applied[m.Id] = target;
+ Logger.Log($"[{c.Name}] '{m.Name}' en el hueco {slot.Area} ({target.Width}x{target.Height}).", c.Id);
+ }
+ WriteCompositeFile(c);
+ Interlocked.Increment(ref _compositeGeneration);
+ }
+
+ private void WriteCompositeFile(StreamSession c)
+ {
+ var parts = c.Composite!
+ .Select(slot => (_sessions.TryGetValue(slot.Session, out var m) && m.State == SessionState.Running ? m.RdpSessionId : 0u, slot.Area))
+ .ToList();
+ var path = Path.Combine(SunshineConfigDir(c.Id), MosaicLayout.FileName);
+ var text = MosaicLayout.Render(c.RdpWidth, c.RdpHeight, parts);
+ if (File.Exists(path) && File.ReadAllText(path) == text) return;
+ Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+ var tmp = path + ".tmp";
+ File.WriteAllText(tmp, text);
+ File.Move(tmp, path, overwrite: true);
+ }
+
+ ///
+ /// Suelta los miembros de una compuesta que se para (o que no llegó a arrancar): cada uno
+ /// vuelve a su tamaño y a su Sunshine, y se paran los que arrancó ella.
+ ///
+ /// Reinicio de la compuesta: los miembros que arrancó siguen en marcha y siguen siendo suyos.
+ private void ReleaseComposite(StreamSession c, bool restarting = false)
+ {
+ try { File.Delete(Path.Combine(SunshineConfigDir(c.Id), MosaicLayout.FileName)); }
+ catch (Exception ex) { Logger.Warning($"[{c.Name}] No se pudo borrar {MosaicLayout.FileName}: {ex.Message}", c.Id); }
+
+ _compositeApplied.TryRemove(c.Id, out var applied);
+ HashSet? started = null;
+ if (restarting) started = null;
+ else _compositeStarted.TryRemove(c.Id, out started);
+ foreach (var slot in c.Composite ?? [])
+ {
+ if (!_sessions.TryGetValue(slot.Session, out var m) || (m.CompositeOf is { } of && of != c.Id)) continue;
+ bool ownedByUs = m.CompositeOf == c.Id;
+ m.CompositeOf = null;
+ if (started is not null && started.Contains(m.Id))
+ {
+ Logger.Log($"[{c.Name}] Parando '{m.Name}', que arrancó la sesión compuesta.", c.Id);
+ if (ownedByUs) ResumeSunshine(m.Id);
+ if (m.State is SessionState.Running or SessionState.Starting)
+ _ = Task.Run(() => { try { Stop(m.Id); } catch { } });
+ continue;
+ }
+ if (!ownedByUs) continue;
+ if (m.State == SessionState.Running && applied?.GetValueOrDefault(m.Id) is { } size &&
+ size != (m.RdpWidth, m.RdpHeight))
+ {
+ try { ReconnectRdp(m.Id, m.RdpWidth, m.RdpHeight, m.RdpFrameRate); }
+ catch (Exception ex) { Logger.Warning($"[{c.Name}] '{m.Name}' no pudo volver a su resolución: {ex.Message}", c.Id); }
+ }
+ ResumeSunshine(m.Id);
+ }
+ Interlocked.Increment(ref _compositeGeneration);
+ }
+
+ // ── Vigilancia (desde MonitorAll, cada 5 s) ──────────────────────────────
+
+ ///
+ /// Mantiene las compuestas en marcha: si se para la sesión del teclado, se para la compuesta;
+ /// si cambia su sesión de Windows, su Sunshine se relanza en la nueva; un miembro que vuelve a
+ /// arrancar se pone otra vez en pausa y en su hueco.
+ ///
+ private void WatchComposites()
+ {
+ foreach (var c in _sessions.Values.Where(s => s.IsComposite && s.State == SessionState.Running).ToList())
+ {
+ try
+ {
+ var ownerId = c.CompositeInput ?? c.Composite![0].Session;
+ if (!_sessions.TryGetValue(ownerId, out var owner) || owner.State != SessionState.Running || owner.RdpSessionId == 0)
+ {
+ Logger.Warning($"[{c.Name}] La sesión del teclado se ha parado: se para la sesión compuesta.", c.Id);
+ _ = Task.Run(() => { try { Stop(c.Id); } catch { } });
+ continue;
+ }
+
+ bool changed = false;
+ foreach (var slot in c.Composite!)
+ {
+ if (!_sessions.TryGetValue(slot.Session, out var m) || m.State != SessionState.Running) continue;
+ // Arrancó de nuevo (parada a mano y vuelta a arrancar): su Sunshine propio fuera.
+ if (m.CompositeOf != c.Id || m.SunshinePid != 0 || _sunshine.ContainsKey(m.Id))
+ {
+ if (_sunshine.TryRemove(m.Id, out var mgr))
+ try { mgr.Stop(); } catch { }
+ m.SunshinePid = 0;
+ PauseSunshine(m.Id, $"sesión compuesta '{c.Name}'");
+ m.CompositeOf = c.Id;
+ if (_compositeApplied.TryGetValue(c.Id, out var applied)) applied[m.Id] = (m.RdpWidth, m.RdpHeight);
+ changed = true;
+ }
+ }
+ if (changed) ApplyComposite(c);
+ else WriteCompositeFile(c); // una sesión de Windows que cambió o un miembro que se paró
+
+ if (owner.RdpSessionId != c.RdpSessionId)
+ {
+ Logger.Log($"[{c.Name}] La sesión del teclado pasó a la sesión de Windows {owner.RdpSessionId}: se relanza Sunshine.", c.Id);
+ RelaunchSunshine(c, "cambio de sesión de Windows");
+ c.RdpSessionId = owner.RdpSessionId;
+ Interlocked.Increment(ref _compositeGeneration);
+ }
+ }
+ catch (Exception ex)
+ {
+ Logger.Warning($"[{c.Name}] Error vigilando la sesión compuesta: {ex.Message}", c.Id);
+ }
+ }
+ }
+
+ // ── Mandos ───────────────────────────────────────────────────────────────
+
+ ///
+ /// Sesión a la que va el mando número que creó el Sunshine de
+ /// : la del hueco N si es una compuesta en
+ /// marcha y ese hueco tiene sesión en marcha; si no, la del teclado. Null si no es una compuesta.
+ ///
+ public Guid? CompositePadTarget(Guid creator, int index)
+ {
+ if (!_sessions.TryGetValue(creator, out var c) || !c.IsComposite || c.State != SessionState.Running)
+ return null;
+ var slots = c.Composite!;
+ if (index >= 0 && index < slots.Count && _sessions.TryGetValue(slots[index].Session, out var m) &&
+ m.State == SessionState.Running && m.RdpSessionId > 0)
+ return m.Id;
+ return c.CompositeInput ?? slots[0].Session;
+ }
+}
diff --git a/Core/Api/StreamSessionService.cs b/Core/Api/StreamSessionService.cs
index a807e5c..5a2953f 100644
--- a/Core/Api/StreamSessionService.cs
+++ b/Core/Api/StreamSessionService.cs
@@ -19,7 +19,7 @@ namespace OpenStreamMS.Core.Api;
/// Hilo-seguro; el estado de cada sesión se actualiza desde tareas en segundo plano.
/// Las sesiones se persisten en sessions.json para sobrevivir reinicios del servicio.
///
-public class StreamSessionService
+public partial class StreamSessionService
{
private readonly ServiceConfig _defaultConfig;
private readonly ConcurrentDictionary _sessions = new();
@@ -177,6 +177,8 @@ public bool Delete(Guid id, bool keepUser = false)
if (!_sessions.TryGetValue(id, out var session)) return false;
if (session.State is SessionState.Starting or SessionState.Running or SessionState.Stopping)
throw new InvalidOperationException(RequestCulture.T("error.stopSession"));
+ if (CompositesUsing(id).FirstOrDefault() is { } composite)
+ throw new InvalidOperationException(RequestCulture.T("error.compositeMemberDelete", session.Name, composite.Name));
// Una sesión que acabó en Error puede conservar la sesión de Windows, el cliente RDP o
// Sunshine: se cierran antes de borrarla, o quedarían sin dueño (y la carpeta, bloqueada).
@@ -583,7 +585,7 @@ private void DoRestart(StreamSession session, int generation)
Logger.SetSessionContext(session.Id);
try
{
- ForceStopInternal(session);
+ ForceStopInternal(session, restarting: true);
// Pausa breve para que Windows libere el sessionId y los locks del usuario
Thread.Sleep(1500);
@@ -611,7 +613,7 @@ private void DoRestart(StreamSession session, int generation)
/// Lógica de force-kill compartida por Stop y Restart. Mata FreeRDP, Sunshine y hace logoff
/// de la sesión Windows. Siempre deja la sesión en estado Stopped al terminar.
///
- private void ForceStopInternal(StreamSession session)
+ private void ForceStopInternal(StreamSession session, bool restarting = false)
{
try
{
@@ -634,7 +636,8 @@ private void ForceStopInternal(StreamSession session)
// quien usa el PC: de ella solo se para Sunshine.
if (session.RdpSessionId > 0)
{
- if (!session.Local && !StreamProfileSetup.LogoffSession(session.RdpSessionId))
+ // La compuesta corre en la sesión de Windows de uno de sus miembros: tampoco se cierra.
+ if (!session.Local && !session.IsComposite && !StreamProfileSetup.LogoffSession(session.RdpSessionId))
Logger.Warning($"[{session.Name}] La sesión Windows {session.RdpSessionId} no terminó de cerrarse.", session.Id);
session.RdpSessionId = 0;
}
@@ -654,6 +657,9 @@ private void ForceStopInternal(StreamSession session)
session.FreeRdpPid = 0;
}
+ if (session.IsComposite)
+ ReleaseComposite(session, restarting);
+
// Modo efímero: borrar el perfil del usuario aislado en segundo plano
// (profsvc tarda unos segundos en descargar el hive tras el logoff)
if (session.Isolated && session.IsolatedEphemeral)
@@ -770,6 +776,7 @@ public void AutoStartEnabled()
public void MonitorAll()
{
+ WatchComposites();
foreach (var session in _sessions.Values.Where(s => s.State == SessionState.Running &&
!_sunshineRelaunching.ContainsKey(s.Id) &&
!_sunshinePaused.ContainsKey(s.Id)))
@@ -855,7 +862,9 @@ private void SaveSessions()
Local: s.Local,
IsolatedUsername: s.IsolatedUsername,
RdpDisplayScale: s.RdpDisplayScale,
- RdpComposition: s.RdpComposition));
+ RdpComposition: s.RdpComposition,
+ Composite: s.Composite,
+ CompositeInput: s.CompositeInput));
var json = JsonSerializer.Serialize(data, JsonOpts);
// Fichero temporal + cambio de nombre: un corte a mitad de escritura no deja
// sessions.json truncado (se perderían todas las sesiones). El lock evita que dos
@@ -949,6 +958,8 @@ private void LoadSessions()
WebRtcMediaPortMin = d.WebRtcMediaPortMin,
WebRtcMediaPortMax = d.WebRtcMediaPortMax,
Local = d.Local,
+ Composite = d.Composite is { Count: > 0 } slots ? slots.ToList() : null,
+ CompositeInput = d.CompositeInput,
State = SessionState.Stopped,
};
@@ -1049,6 +1060,11 @@ private void DoStartLocked(StreamSession session, int generation)
StartLocal(session, generation);
return;
}
+ if (session.IsComposite)
+ {
+ StartComposite(session, generation);
+ return;
+ }
session.StartPhase = "user";
@@ -1512,7 +1528,7 @@ private void AdoptStreamProtocolFromSunshine(StreamSession session)
private static bool UsesRemoteIdd(StreamSession session) =>
WantsRemoteIdd(session) && RdpWrapperManager.IsRemoteIddUsable();
- /// La sesión se captura con RemoteIdd (requisito del mosaico).
+ /// La sesión se captura con RemoteIdd (requisito de las sesiones compuestas).
public static bool CapturesWithRemoteIdd(StreamSession session) => UsesRemoteIdd(session);
/// Carpeta config del Sunshine de la sesión (la de sunshine.conf).
@@ -1930,5 +1946,9 @@ private record SessionData(
/// Escala de la pantalla en %. 0 en sesiones anteriores = 100.
int RdpDisplayScale = 100,
/// Ritmo de composición. Null en sesiones anteriores = Smooth.
- RdpCompositionMode? RdpComposition = null);
+ RdpCompositionMode? RdpComposition = null,
+ /// Huecos de una sesión compuesta. Null en las sesiones normales.
+ List? Composite = null,
+ /// Sesión del teclado, el ratón y el audio de una compuesta.
+ Guid? CompositeInput = null);
}
diff --git a/Core/wwwroot/app.js b/Core/wwwroot/app.js
index 1b23fd2..eb646d8 100644
--- a/Core/wwwroot/app.js
+++ b/Core/wwwroot/app.js
@@ -140,7 +140,7 @@ function renderSessions() {
function renderCard(s) {
const isRunning = s.state === 'Running';
const isBusy = s.state === 'Starting' || s.state === 'Stopping';
- const screen = s.local
+ const screen = s.composite ? compositeThumb(s) : s.local
? `