tom/hermes-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Using Serilog. Added partial OBS batch request support. Added update checking. Added more commands. Added enabled/disabled TTS voices. And more.

Browse Source
This commit is contained in:
Tom
2024-06-17 00:19:31 +00:00
parent d4004d6230
commit 706cd06930
67 changed files with 1933 additions and 925 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
OBS/Socket/Context/HelloContext.cs
View File

@ -1,6 +1,5 @@
namespace TwitchChatTTS.OBS.Socket.Context
{
[Serializable]
public class HelloContext
{
public string? Host { get; set; }

1
OBS/Socket/Data/EventMessage.cs
View File

@ -1,6 +1,5 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
[Serializable]
public class EventMessage
{
public string EventType { get; set; }

1
OBS/Socket/Data/HelloMessage.cs
View File

@ -1,6 +1,5 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
[Serializable]
public class HelloMessage
{
public string ObsWebSocketVersion { get; set; }

1
OBS/Socket/Data/IdentifiedMessage.cs
View File

@ -1,6 +1,5 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
[Serializable]
public class IdentifiedMessage
{
public int NegotiatedRpcVersion { get; set; }

4
OBS/Socket/Data/IdentifyMessage.cs
View File

@ -1,13 +1,13 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
[Serializable]
public class IdentifyMessage
{
public int RpcVersion { get; set; }
public string? Authentication { get; set; }
public int EventSubscriptions { get; set; }
public IdentifyMessage(int version, string auth, int subscriptions) {
public IdentifyMessage(int version, string auth, int subscriptions)
{
RpcVersion = version;
Authentication = auth;
EventSubscriptions = subscriptions;

25
OBS/Socket/Data/RequestBatchMessage.cs Normal file
View File

@ -0,0 +1,25 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
public class RequestBatchMessage
{
public string RequestId { get; set; }
public bool HaltOnFailure { get; set; }
public RequestBatchExecutionType ExecutionType { get; set; }
public IEnumerable<object> Requests { get; set;}
public RequestBatchMessage(string id, IEnumerable<object> requests, bool haltOnFailure = false, RequestBatchExecutionType executionType = RequestBatchExecutionType.SerialRealtime)
{
RequestId = id;
Requests = requests;
HaltOnFailure = haltOnFailure;
ExecutionType = executionType;
}
}
public enum RequestBatchExecutionType {
None = -1,
SerialRealtime = 0,
SerialFrame = 1,
Parallel = 2
}
}

8
OBS/Socket/Data/RequestBatchResponseMessage.cs Normal file
View File

@ -0,0 +1,8 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
public class RequestBatchResponseMessage
{
public string RequestId { get; set; }
public IEnumerable<object> Results { get; set; }
}
}

4
OBS/Socket/Data/RequestMessage.cs
View File

@ -1,13 +1,13 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
[Serializable]
public class RequestMessage
{
public string RequestType { get; set; }
public string RequestId { get; set; }
public Dictionary<string, object> RequestData { get; set; }
public RequestMessage(string type, string id, Dictionary<string, object> data) {
public RequestMessage(string type, string id, Dictionary<string, object> data)
{
RequestType = type;
RequestId = id;
RequestData = data;

1
OBS/Socket/Data/RequestResponseMessage.cs
View File

@ -1,6 +1,5 @@
namespace TwitchChatTTS.OBS.Socket.Data
{
[Serializable]
public class RequestResponseMessage
{
public string RequestType { get; set; }

28
OBS/Socket/Handlers/EventMessageHandler.cs
View File

@ -1,19 +1,20 @@
using CommonSocketLibrary.Abstract;
using CommonSocketLibrary.Common;
using Microsoft.Extensions.Logging;
using Serilog;
using TwitchChatTTS.OBS.Socket.Data;
namespace TwitchChatTTS.OBS.Socket.Handlers
{
public class EventMessageHandler : IWebSocketHandler
{
private ILogger Logger { get; }
private IServiceProvider ServiceProvider { get; }
private ILogger _logger { get; }
private IServiceProvider _serviceProvider { get; }
public int OperationCode { get; set; } = 5;
public EventMessageHandler(ILogger<EventMessageHandler> logger, IServiceProvider serviceProvider) {
Logger = logger;
ServiceProvider = serviceProvider;
public EventMessageHandler(ILogger logger, IServiceProvider serviceProvider)
{
_logger = logger;
_serviceProvider = serviceProvider;
}
public async Task Execute<Data>(SocketClient<WebSocketMessage> sender, Data message)
@ -21,28 +22,31 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
if (message is not EventMessage obj || obj == null)
return;
switch (obj.EventType) {
switch (obj.EventType)
{
case "StreamStateChanged":
case "RecordStateChanged":
if (sender is not OBSSocketClient client)
return;
string? raw_state = obj.EventData["outputState"].ToString();
string? state = raw_state?.Substring(21).ToLower();
client.Live = obj.EventData["outputActive"].ToString() == "True";
Logger.LogWarning("Stream " + (state != null && state.EndsWith("ing") ? "is " : "has ") + state + ".");
_logger.Warning("Stream " + (state != null && state.EndsWith("ing") ? "is " : "has ") + state + ".");
if (client.Live == false && state != null && !state.EndsWith("ing")) {
if (client.Live == false && state != null && !state.EndsWith("ing"))
{
OnStreamEnd();
}
break;
default:
Logger.LogDebug(obj.EventType + " EVENT: " + string.Join(" | ", obj.EventData?.Select(x => x.Key + "=" + x.Value?.ToString()) ?? new string[0]));
_logger.Debug(obj.EventType + " EVENT: " + string.Join(" | ", obj.EventData?.Select(x => x.Key + "=" + x.Value?.ToString()) ?? new string[0]));
break;
}
}
private void OnStreamEnd() {
private void OnStreamEnd()
{
}
}
}

35
OBS/Socket/Handlers/HelloHandler.cs
View File

@ -2,7 +2,7 @@ using System.Security.Cryptography;
using System.Text;
using CommonSocketLibrary.Abstract;
using CommonSocketLibrary.Common;
using Microsoft.Extensions.Logging;
using Serilog;
using TwitchChatTTS.OBS.Socket.Data;
using TwitchChatTTS.OBS.Socket.Context;
@ -10,13 +10,14 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
{
public class HelloHandler : IWebSocketHandler
{
private ILogger Logger { get; }
private ILogger _logger { get; }
public int OperationCode { get; set; } = 0;
private HelloContext Context { get; }
private HelloContext _context { get; }
public HelloHandler(ILogger<HelloHandler> logger, HelloContext context) {
Logger = logger;
Context = context;
public HelloHandler(ILogger logger, HelloContext context)
{
_logger = logger;
_context = context;
}
public async Task Execute<Data>(SocketClient<WebSocketMessage> sender, Data message)
@ -24,19 +25,23 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
if (message is not HelloMessage obj || obj == null)
return;
Logger.LogTrace("OBS websocket password: " + Context.Password);
if (obj.Authentication == null || Context.Password == null) // TODO: send re-identify message.
_logger.Verbose("OBS websocket password: " + _context.Password);
if (obj.Authentication == null || string.IsNullOrWhiteSpace(_context.Password))
{
await sender.Send(1, new IdentifyMessage(obj.RpcVersion, string.Empty, 1023 | 262144));
return;
}
var salt = obj.Authentication.Salt;
var challenge = obj.Authentication.Challenge;
Logger.LogTrace("Salt: " + salt);
Logger.LogTrace("Challenge: " + challenge);
string secret = Context.Password + salt;
_logger.Verbose("Salt: " + salt);
_logger.Verbose("Challenge: " + challenge);
string secret = _context.Password + salt;
byte[] bytes = Encoding.UTF8.GetBytes(secret);
string hash = null;
using (var sha = SHA256.Create()) {
using (var sha = SHA256.Create())
{
bytes = sha.ComputeHash(bytes);
hash = Convert.ToBase64String(bytes);
@ -46,7 +51,7 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
hash = Convert.ToBase64String(bytes);
}
Logger.LogTrace("Final hash: " + hash);
_logger.Verbose("Final hash: " + hash);
await sender.Send(1, new IdentifyMessage(obj.RpcVersion, hash, 1023 | 262144));
}
}

9
OBS/Socket/Handlers/IdentifiedHandler.cs
View File

@ -1,6 +1,6 @@
using CommonSocketLibrary.Abstract;
using CommonSocketLibrary.Common;
using Microsoft.Extensions.Logging;
using Serilog;
using TwitchChatTTS.OBS.Socket.Data;
namespace TwitchChatTTS.OBS.Socket.Handlers
@ -10,7 +10,8 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
private ILogger Logger { get; }
public int OperationCode { get; set; } = 2;
public IdentifiedHandler(ILogger<IdentifiedHandler> logger) {
public IdentifiedHandler(ILogger logger)
{
Logger = logger;
}
@ -18,9 +19,9 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
{
if (message is not IdentifiedMessage obj || obj == null)
return;
sender.Connected = true;
Logger.LogInformation("Connected to OBS via rpc version " + obj.NegotiatedRpcVersion + ".");
Logger.Information("Connected to OBS via rpc version " + obj.NegotiatedRpcVersion + ".");
}
}
}

85
OBS/Socket/Handlers/RequestBatchResponseHandler.cs Normal file
View File

@ -0,0 +1,85 @@
using System.Text.Json;
using CommonSocketLibrary.Abstract;
using CommonSocketLibrary.Common;
using Microsoft.Extensions.DependencyInjection;
using Serilog;
using Serilog.Context;
using TwitchChatTTS.OBS.Socket.Data;
using TwitchChatTTS.OBS.Socket.Manager;
namespace TwitchChatTTS.OBS.Socket.Handlers
{
public class RequestBatchResponseHandler : IWebSocketHandler
{
private OBSRequestBatchManager _manager { get; }
private IServiceProvider _serviceProvider { get; }
private ILogger _logger { get; }
private JsonSerializerOptions _options;
public int OperationCode { get; set; } = 9;
public RequestBatchResponseHandler(OBSRequestBatchManager manager, JsonSerializerOptions options, IServiceProvider serviceProvider, ILogger logger)
{
_manager = manager;
_serviceProvider = serviceProvider;
_logger = logger;
_options = options;
}
public async Task Execute<Data>(SocketClient<WebSocketMessage> sender, Data data)
{
if (data is not RequestBatchResponseMessage message || message == null)
return;
using (LogContext.PushProperty("obsrid", message.RequestId))
{
var results = message.Results.ToList();
_logger.Debug($"Received request batch response of {results.Count} messages.");
var requestData = _manager.Take(message.RequestId);
if (requestData == null || !results.Any())
{
_logger.Verbose($"Received request batch response of {results.Count} messages.");
return;
}
IList<Task> tasks = new List<Task>();
int count = Math.Min(results.Count, requestData.RequestTypes.Count);
for (int i = 0; i < count; i++)
{
Type type = requestData.RequestTypes[i];
using (LogContext.PushProperty("type", type.Name))
{
try
{
var handler = GetResponseHandlerForRequestType(type);
_logger.Verbose($"Request handled by {handler.GetType().Name}.");
tasks.Add(handler.Execute(sender, results[i]));
}
catch (Exception ex)
{
_logger.Error(ex, "Failed to process an item in a request batch message.");
}
}
}
_logger.Verbose($"Waiting for processing to complete.");
await Task.WhenAll(tasks);
_logger.Debug($"Finished processing all request in this batch.");
}
}
private IWebSocketHandler? GetResponseHandlerForRequestType(Type type)
{
if (type == typeof(RequestMessage))
return _serviceProvider.GetRequiredKeyedService<IWebSocketHandler>("obs-requestresponse");
else if (type == typeof(RequestBatchMessage))
return _serviceProvider.GetRequiredKeyedService<IWebSocketHandler>("obs-requestbatcresponse");
else if (type == typeof(IdentifyMessage))
return _serviceProvider.GetRequiredKeyedService<IWebSocketHandler>("obs-identified");
return null;
}
}
}

17
OBS/Socket/Handlers/RequestResponseHandler.cs
View File

@ -1,6 +1,6 @@
using CommonSocketLibrary.Abstract;
using CommonSocketLibrary.Common;
using Microsoft.Extensions.Logging;
using Serilog;
using TwitchChatTTS.OBS.Socket.Data;
namespace TwitchChatTTS.OBS.Socket.Handlers
@ -10,7 +10,8 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
private ILogger Logger { get; }
public int OperationCode { get; set; } = 7;
public RequestResponseHandler(ILogger<RequestResponseHandler> logger) {
public RequestResponseHandler(ILogger logger)
{
Logger = logger;
}
@ -18,15 +19,17 @@ namespace TwitchChatTTS.OBS.Socket.Handlers
{
if (message is not RequestResponseMessage obj || obj == null)
return;
switch (obj.RequestType) {
switch (obj.RequestType)
{
case "GetOutputStatus":
if (sender is not OBSSocketClient client)
return;
if (obj.RequestId == "stream") {
if (obj.RequestId == "stream")
{
client.Live = obj.ResponseData["outputActive"].ToString() == "True";
Logger.LogWarning("Updated stream's live status to " + client.Live);
Logger.Warning("Updated stream's live status to " + client.Live);
}
break;
}

60
OBS/Socket/Manager/OBSBatchRequestManager.cs Normal file
View File

@ -0,0 +1,60 @@
using CommonSocketLibrary.Abstract;
using CommonSocketLibrary.Common;
using Microsoft.Extensions.DependencyInjection;
using Serilog;
using TwitchChatTTS.OBS.Socket.Data;
namespace TwitchChatTTS.OBS.Socket.Manager
{
public class OBSRequestBatchManager
{
private IDictionary<string, OBSRequestBatchData> _requests;
private IServiceProvider _serviceProvider;
private ILogger _logger;
public OBSRequestBatchManager(IServiceProvider serviceProvider, ILogger logger)
{
_serviceProvider = serviceProvider;
_logger = logger;
}
public async Task Send(long broadcasterId, IEnumerable<WebSocketMessage> messages) {
string uid = GenerateUniqueIdentifier();
var data = new OBSRequestBatchData(broadcasterId, uid, new List<Type>());
_logger.Debug($"Sending request batch of {messages.Count()} messages.");
foreach (WebSocketMessage message in messages)
data.RequestTypes.Add(message.GetType());
var client = _serviceProvider.GetRequiredKeyedService<SocketClient<WebSocketMessage>>("obs");
await client.Send(8, new RequestBatchMessage(uid, messages));
}
public OBSRequestBatchData? Take(string id) {
if (_requests.TryGetValue(id, out var request)) {
_requests.Remove(id);
return request;
}
return null;
}
private string GenerateUniqueIdentifier()
{
return Guid.NewGuid().ToString("X");
}
}
public class OBSRequestBatchData
{
public long BroadcasterId { get; }
public string RequestId { get; }
public IList<Type> RequestTypes { get; }
public OBSRequestBatchData(long bid, string rid, IList<Type> types) {
BroadcasterId = bid;
RequestId = rid;
RequestTypes = types;
}
}
}

17
OBS/Socket/Manager/OBSHandlerManager.cs
View File

@ -1,4 +1,4 @@
using Microsoft.Extensions.Logging;
using Serilog;
using Microsoft.Extensions.DependencyInjection;
using CommonSocketLibrary.Socket.Manager;
using CommonSocketLibrary.Common;
@ -7,23 +7,26 @@ namespace TwitchChatTTS.OBS.Socket.Manager
{
public class OBSHandlerManager : WebSocketHandlerManager
{
public OBSHandlerManager(ILogger<OBSHandlerManager> logger, IServiceProvider provider) : base(logger) {
public OBSHandlerManager(ILogger logger, IServiceProvider provider) : base(logger)
{
var basetype = typeof(IWebSocketHandler);
var assembly = GetType().Assembly;
var types = assembly.GetTypes().Where(t => t.IsClass && basetype.IsAssignableFrom(t) && t.AssemblyQualifiedName?.Contains(".OBS.") == true);
foreach (var type in types) {
foreach (var type in types)
{
var key = "obs-" + type.Name.Replace("Handlers", "Hand#lers")
.Replace("Handler", "")
.Replace("Hand#lers", "Handlers")
.ToLower();
var handler = provider.GetKeyedService<IWebSocketHandler>(key);
if (handler == null) {
logger.LogError("Failed to find obs websocket handler: " + type.AssemblyQualifiedName);
if (handler == null)
{
logger.Error("Failed to find obs websocket handler: " + type.AssemblyQualifiedName);
continue;
}
Logger.LogDebug($"Linked type {type.AssemblyQualifiedName} to obs websocket handler {handler.GetType().AssemblyQualifiedName}.");
Logger.Debug($"Linked type {type.AssemblyQualifiedName} to obs websocket handler {handler.GetType().AssemblyQualifiedName}.");
Add(handler);
}
}

4
OBS/Socket/Manager/OBSHandlerTypeManager.cs
View File

@ -2,14 +2,14 @@ using CommonSocketLibrary.Abstract;
using CommonSocketLibrary.Common;
using CommonSocketLibrary.Socket.Manager;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Serilog;
namespace TwitchChatTTS.OBS.Socket.Manager
{
public class OBSHandlerTypeManager : WebSocketHandlerTypeManager
{
public OBSHandlerTypeManager(
ILogger<OBSHandlerTypeManager> factory,
ILogger factory,
[FromKeyedServices("obs")] HandlerManager<WebSocketClient, IWebSocketHandler> handlers
) : base(factory, handlers)
{

19
OBS/Socket/OBSSocketClient.cs
View File

@ -1,29 +1,34 @@
using CommonSocketLibrary.Common;
using CommonSocketLibrary.Abstract;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Serilog;
using System.Text.Json;
namespace TwitchChatTTS.OBS.Socket
{
public class OBSSocketClient : WebSocketClient {
public class OBSSocketClient : WebSocketClient
{
private bool _live;
public bool? Live {
public bool? Live
{
get => Connected ? _live : null;
set {
set
{
if (value.HasValue)
_live = value.Value;
}
}
public OBSSocketClient(
ILogger<OBSSocketClient> logger,
ILogger logger,
[FromKeyedServices("obs")] HandlerManager<WebSocketClient, IWebSocketHandler> handlerManager,
[FromKeyedServices("obs")] HandlerTypeManager<WebSocketClient, IWebSocketHandler> typeManager
) : base(logger, handlerManager, typeManager, new JsonSerializerOptions() {
) : base(logger, handlerManager, typeManager, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = false,
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
}) {
})
{
_live = false;
}
}