protected override async Task ExecuteAsync(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
try
{
bool anyChanged = false;
Logger.LogInfo("Poll database...");
var competitionClasses = _results.Processor.GetClasses();
Logger.LogInfo($"Found {competitionClasses.Count} classes");
foreach (var competitionClass in competitionClasses)
{
if (!_lastCheckDictionary.TryGetValue(competitionClass.Id, out DateTime lastCheckTime))
{
lastCheckTime = DateTime.MinValue;
}
Logger.LogInfo($"Checking new results in '{competitionClass.ShortName}' ({competitionClass.Id}) since {lastCheckTime}");
bool resultsChanged = _results.Processor.ClassHasNewResults(competitionClass.Id, lastCheckTime);
if (resultsChanged)
{
anyChanged = true;
Logger.LogInfo($"Fetching results for {competitionClass.ShortName}");
var results = _results.Processor.GetClass(competitionClass.Id);
await MqttPublisher.PublishAsync(results);
var lastModified = results.Results.Aggregate((r1, r2) => r1.ModifyDate > r2.ModifyDate ? r1 : r2).ModifyDate;
Logger.LogInfo($"Updating last check time for '{competitionClass.ShortName}' to {lastModified}");
_lastCheckDictionary[competitionClass.Id] = lastModified;
}
else
{
Logger.LogInfo("No new results found");
}
}
if (anyChanged)
{
var finish = _results.Processor.Finish(50);
await MqttPublisher.PublishAsync(finish);
}
var memoryUsed = GC.GetTotalMemory(false);
Logger.LogInfo($"Memory usage: { +memoryUsed / 1024 / 1024 } MB");
if (memoryUsed >= 70 * 1024 * 1024)
{
Logger.LogInfo("Forcing garbage collect");
GC.Collect();
Logger.LogInfo($"Memory usage after collect: { GC.GetTotalMemory(true) / 1024 / 1024 } MB");
}
}
catch (Exception exception)
{
Logger.LogError("Failed poll database", exception);
}
await Task.Delay(TimeSpan.FromMilliseconds(_conf.PollWaitTime), cancellationToken);
}
}
public Worker(ILogger <Worker> logger,
IConfigurationService configuredSensorsService,
MqttPublisher mqttPublisher)
{
_logger = logger;
this._configurationService = configuredSensorsService;
this._mqttPublisher = mqttPublisher;
}
public async void ReadCommandSettings(MqttPublisher publisher)
{
while (this.CommandSettingsFileLocked)
{
await Task.Delay(500);
}
this.CommandSettingsFileLocked = true;
List <ConfiguredCommand> commands = new List <ConfiguredCommand>();
using (var stream = new FileStream(Path.Combine(path, "configured-commands.json"), FileMode.Open))
{
Log.Logger.Information($"reading configured commands from: {stream.Name}");
if (stream.Length > 0)
{
commands = await JsonSerializer.DeserializeAsync <List <ConfiguredCommand> >(stream);
}
stream.Close();
this.CommandSettingsFileLocked = false;
}
foreach (ConfiguredCommand configuredCommand in commands)
{
AbstractCommand command = null;
switch (configuredCommand.Type)
{
case "ShutdownCommand":
command = new ShutdownCommand(publisher, configuredCommand.Name, configuredCommand.Id);
break;
case "RestartCommand":
command = new RestartCommand(publisher, configuredCommand.Name, configuredCommand.Id);
break;
case "LogOffCommand":
command = new LogOffCommand(publisher, configuredCommand.Name, configuredCommand.Id);
break;
case "CustomCommand":
command = new CustomCommand(publisher, configuredCommand.Command, configuredCommand.Name, configuredCommand.Id);
break;
default:
Log.Logger.Error("unsupported command type in config");
break;
}
if (command != null)
{
this.ConfiguredCommands.Add(command);
}
}
}
public AbstractCommand(MqttPublisher publisher, string name, Guid id = default(Guid))
{
if (id == Guid.Empty)
{
this.Id = Guid.NewGuid();
}
else
{
this.Id = id;
}
this.Name = name;
this.Publisher = publisher;
publisher.Subscribe(this);
}
public AbstractSensor(MqttPublisher publisher, string name, int updateInterval = 10, Guid id = default(Guid))
{
if (id == Guid.Empty)
{
this.Id = Guid.NewGuid();
}
else
{
this.Id = id;
}
this.Name = name;
this.Publisher = publisher;
this.UpdateInterval = updateInterval;
}
public GpuLoadSensor(MqttPublisher publisher, int?updateInterval = null, string name = "GPULoad", Guid id = default(Guid)) : base(publisher, name ?? "GPULoad", updateInterval ?? 10, id)
{
_computer = new Computer
{
IsCpuEnabled = false,
IsGpuEnabled = true,
IsMemoryEnabled = false,
IsMotherboardEnabled = false,
IsControllerEnabled = false,
IsNetworkEnabled = false,
IsStorageEnabled = false,
};
_computer.Open();
this._gpu = _computer.Hardware.FirstOrDefault(h => h.HardwareType == HardwareType.GpuAmd || h.HardwareType == HardwareType.GpuNvidia);
}
protected override void Load(ContainerBuilder builder)
{
//register MQTT devices pool
builder.RegisterType <SysMonitorsPool>()
.As <ISysMonitorsPool>()
.SingleInstance();
//declare Mqtt client
builder.RegisterType <MqttFactory>().AsSelf();
builder.Register(c => c.Resolve <MqttFactory>().CreateMqttClient())
.As <IMqttClient>();
//register Mqtt MqttPublisher
builder.RegisterType <MqttPublisher>()
.WithParameter(new TypedParameter(typeof(ISocketPrefs), MqttPublisher.GetDefaultPrefs()))
.As <IMqttPublisher>();
//register devices
builder.RegisterType <MqttCpuTemperatureMonitor>().SingleInstance();
builder.Register <IMqttMessageSender>((c, p) =>
{
var parameters = p.ToList();
if (parameters.Count == 0)
{
return(c.Resolve <MqttCpuTemperatureMonitor>());
}
return(new MqttCpuServiceMonitor(parameters.Named <int>("procId"), parameters.Named <string>("serviceName")));
});
//register Mqtt device factory
builder.RegisterType <DeviceFactory>().AsSelf().SingleInstance();
//register callback
builder.RegisterBuildCallback(scope => Ioc = scope);
}
public MediaPreviousCommand(MqttPublisher publisher, string name = "Previous", Guid id = default(Guid)) : base(publisher, KeyCommand.VK_MEDIA_PREV_TRACK, name ?? "Previous", id)
{
}
public Registration_BL(IUsersCollection usersCollection, MqttPublisher mqtt)
{
_usersCollection = usersCollection;
Mqtt = mqtt;
}
static void Main(string[] args)
{
MqttPublisher pub = new MqttPublisher();
pub.Execute();
}
public WebcamActiveSensor(MqttPublisher publisher, int?updateInterval = null, string name = "WebcamActive", Guid id = default) : base(publisher, name ?? "WebcamActive", updateInterval ?? 10, id)
{
}
public NamedWindowSensor(MqttPublisher publisher, string windowName, string name = "NamedWindow", int?updateInterval = 10, Guid id = default) : base(publisher, name ?? "NamedWindow", updateInterval ?? 10, id)
{
this.WindowName = windowName;
}
public async void ReadSensorSettings(MqttPublisher publisher)
{
while (this._sensorsSettingsFileLocked)
{
await Task.Delay(500);
}
this._sensorsSettingsFileLocked = true;
List <ConfiguredSensor> sensors = new List <ConfiguredSensor>();
using (var stream = new FileStream(Path.Combine(path, "configured-sensors.json"), FileMode.Open))
{
Log.Logger.Information($"reading configured sensors from: {stream.Name}");
if (stream.Length > 0)
{
sensors = await JsonSerializer.DeserializeAsync <List <ConfiguredSensor> >(stream);
}
stream.Close();
this._sensorsSettingsFileLocked = false;
}
foreach (ConfiguredSensor configuredSensor in sensors)
{
AbstractSensor sensor = null;
switch (configuredSensor.Type)
{
case "UserNotificationStateSensor":
sensor = new UserNotificationStateSensor(publisher, configuredSensor.UpdateInterval, configuredSensor.Name, configuredSensor.Id);
break;
case "DummySensor":
sensor = new DummySensor(publisher, configuredSensor.UpdateInterval, configuredSensor.Name, configuredSensor.Id);
break;
case "CurrentClockSpeedSensor":
sensor = new CurrentClockSpeedSensor(publisher, configuredSensor.UpdateInterval, configuredSensor.Name, configuredSensor.Id);
break;
case "WMIQuerySensor":
sensor = new WMIQuerySensor(publisher, configuredSensor.Query, configuredSensor.UpdateInterval, configuredSensor.Name, configuredSensor.Id);
break;
case "CPULoadSensor":
sensor = new CPULoadSensor(publisher, configuredSensor.UpdateInterval, configuredSensor.Name, configuredSensor.Id);
break;
case "MemoryUsageSensor":
sensor = new MemoryUsageSensor(publisher, configuredSensor.UpdateInterval, configuredSensor.Name, configuredSensor.Id);
break;
case "ActiveWindowSensor":
sensor = new ActiveWindowSensor(publisher, configuredSensor.UpdateInterval, configuredSensor.Name, configuredSensor.Id);
break;
default:
Log.Logger.Error("unsupported sensor type in config");
break;
}
if (sensor != null)
{
this.ConfiguredSensors.Add(sensor);
}
}
}
public UserNotificationStateSensor(MqttPublisher publisher, int?updateInterval = null, string name = "NotificationState", Guid id = default(Guid)) : base(publisher, name ?? "NotificationState", updateInterval ?? 10, id)
{
}
public DummySensor(MqttPublisher publisher, int?updateInterval = null, string name = "Dummy", Guid id = default(Guid)) : base(publisher, name ?? "Dummy", updateInterval ?? 1, id)
{
this._random = new Random();
}
public LogOffCommand(MqttPublisher publisher, string name = "Shutdown", Guid id = default(Guid)) : base(publisher, "shutdown /l", name ?? "LogOff", id)
{
this.State = "OFF";
}
public MemoryUsageSensor(MqttPublisher publisher, int?updateInterval = null, string name = "MemoryUsage", Guid id = default) : base(publisher, "SELECT FreePhysicalMemory,TotalVisibleMemorySize FROM Win32_OperatingSystem", updateInterval ?? 10, name ?? "MemoryUsage", id)
{
}
public MediaMuteCommand(MqttPublisher publisher, string name = "Mute", Guid id = default(Guid)) : base(publisher, KeyCommand.VK_VOLUME_MUTE, name ?? "Mute", id)
{
}
public InterProcessApi(MqttPublisher publisher, IConfigurationService configurationService)
{
_publisher = publisher;
_configurationService = configurationService;
}
public CPULoadSensor(MqttPublisher publisher, int?updateInterval = null, string name = "CPULoadSensor", Guid id = default) : base(publisher, "SELECT PercentProcessorTime FROM Win32_PerfFormattedData_PerfOS_Processor", updateInterval ?? 10, name ?? "CPULoadSensor", id)
{
}
public WMIQuerySensor(MqttPublisher publisher, string query, int?updateInterval = null, string name = "WMIQuerySensor", Guid id = default) : base(publisher, name ?? "WMIQuerySensor", updateInterval ?? 10, id)
{
this.Query = query;
_objectQuery = new ObjectQuery(this.Query);
_searcher = new ManagementObjectSearcher(query);
}
public LastBootSensor(MqttPublisher publisher, int?updateInterval = 10, string name = "LastBoot", Guid id = default) : base(publisher, name ?? "LastBoot", updateInterval ?? 10, id)
{
}
public IdleTimeSensor(MqttPublisher publisher, int?updateInterval = 10, string name = "IdleTime", Guid id = default) : base(publisher, name ?? "IdleTime", updateInterval ?? 10, id)
{
}
public MediaVolumeDownCommand(MqttPublisher publisher, string name = "VolumeDown", Guid id = default(Guid)) : base(publisher, KeyCommand.VK_VOLUME_DOWN, name ?? "VolumeDown", id)
{
}
public ActiveWindowSensor(MqttPublisher publisher, int?updateInterval = null, string name = "ActiveWindow", Guid id = default(Guid)) : base(publisher, name ?? "ActiveWindow", updateInterval ?? 10, id)
{
}
public RestartCommand(MqttPublisher publisher, string name = "Shutdown", Guid id = default(Guid)) : base(publisher, "shutdown /r", name ?? "Restart", id)
{
this.State = "OFF";
}
public KeyCommand(MqttPublisher publisher, byte keyCode, string name = "Key", Guid id = default(Guid)) : base(publisher, name ?? "Key", id)
{
this.KeyCode = keyCode;
}
public CustomCommand(MqttPublisher publisher, string command, string name = "Custom", Guid id = default(Guid)) : base(publisher, name ?? "Custom", id)
{
this.Command = command;
this.State = "OFF";
}
public CurrentVolumeSensor(MqttPublisher publisher, int?updateInterval = null, string name = "CurrentVolume", Guid id = default(Guid)) : base(publisher, name ?? "CurrentVolume", updateInterval ?? 10, id)
{
this.deviceEnumerator = new MMDeviceEnumerator();
this.devices = deviceEnumerator.EnumerateAudioEndPoints(EDataFlow.eRender, DEVICE_STATE.DEVICE_STATE_ACTIVE);
}
public CurrentClockSpeedSensor(MqttPublisher publisher, int?updateInterval = null, string name = "CurrentClockSpeed", Guid id = default(Guid)) : base(publisher, "SELECT CurrentClockSpeed FROM Win32_Processor", updateInterval ?? 10, name ?? "CurrentClockSpeed", id)
{
}
