Samuele Locatelli
380 lines
11 KiB
C#
380 lines
11 KiB
C#
// See https://aka.ms/new-console-template for more information
|
|
using MachineSim;
|
|
using MP.MONO.Core;
|
|
using MP.MONO.Core.CONF;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using StackExchange.Redis;
|
|
|
|
string lineSep = "---------------------------------------------";
|
|
string redisConf = "nkcredis.steamware.net:6379,DefaultDatabase=7,connectTimeout=5000,syncTimeout=5000,asyncTimeout=5000,abortConnect=false,ssl=false,password=nkc.password";
|
|
|
|
// imposto variabili di base
|
|
string confPath = Path.Combine(Directory.GetCurrentDirectory(), "conf");
|
|
Logger Log = LogManager.GetCurrentClassLogger();
|
|
Random rand = new Random();
|
|
List<MachineStatus>? statusList = new List<MachineStatus>();
|
|
List<MachineMode>? modeList = new List<MachineMode>();
|
|
|
|
// fix numero minimo dei thread pool x evitare collasso chiamate redis
|
|
ThreadPool.SetMinThreads(10, 10);
|
|
|
|
Dictionary<string, int> LogSimulator = new Dictionary<string, int>();
|
|
Dictionary<string, DateTime> LastSend = new Dictionary<string, DateTime>();
|
|
DateTime lastLog = DateTime.Now.AddMinutes(-1);
|
|
bool verboseLog = false;
|
|
bool logWriting = false;
|
|
|
|
logInfo(lineSep, true, true);
|
|
logInfo($"Starting Machine SIM", true, true);
|
|
logInfo($"Redis server param: {redisConf.Substring(0, 20)}...", false, true);
|
|
logInfo(lineSep, true, true);
|
|
logInfo("", true, true);
|
|
logInfo("Running - press CTRL-C to stop SIM", false, true);
|
|
logInfo("", false, true);
|
|
|
|
//Create a connection
|
|
ConnectionMultiplexer.SetFeatureFlag("preventthreadtheft", true);
|
|
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(redisConf);
|
|
ISubscriber sub = redis.GetSubscriber();
|
|
IDatabase? redisDb = redis.GetDatabase();
|
|
|
|
// salvo configurazioni in redis
|
|
setupConf();
|
|
var currSimGen = new Simulator(confPath, modeList.Count, statusList.Count);
|
|
|
|
// preparo la lista dei contatori invio...
|
|
LogSimulator.Add(Constants.ACT_LOG_M_QUEUE, 0);
|
|
LogSimulator.Add(Constants.ALARM_M_QUEUE, 0);
|
|
LogSimulator.Add(Constants.EVENT_LOG_M_QUEUE, 0);
|
|
LogSimulator.Add(Constants.PARAMS_M_QUEUE, 0);
|
|
LogSimulator.Add(Constants.PROD_M_QUEUE, 0);
|
|
LogSimulator.Add(Constants.MACH_STATS_M_QUEUE, 0);
|
|
LogSimulator.Add(Constants.MAINT_STATS_M_QUEUE, 0);
|
|
LogSimulator.Add(Constants.TOOLS_M_QUEUE, 0);
|
|
|
|
// avvio tutti i thread...
|
|
Thread threadStatus = new Thread(simStatus);
|
|
Thread threadAlarms = new Thread(simAlarms);
|
|
Thread threadParams = new Thread(simParameters);
|
|
Thread threadProd = new Thread(simProd);
|
|
Thread threadMachStat = new Thread(simMachStat);
|
|
Thread threadMaint = new Thread(simMaint);
|
|
Thread threadTools = new Thread(simTools);
|
|
Thread threadEvHistory = new Thread(simEvents);
|
|
Thread threadActLog = new Thread(simActivityLog);
|
|
|
|
threadStatus.Start();
|
|
threadAlarms.Start();
|
|
threadParams.Start();
|
|
threadProd.Start();
|
|
threadMachStat.Start();
|
|
threadMaint.Start();
|
|
threadTools.Start();
|
|
threadEvHistory.Start();
|
|
threadActLog.Start();
|
|
|
|
/// <summary>
|
|
/// verifica esistenza file oppure lo crea...
|
|
/// </summary>
|
|
void checkFilePresent(string filePath)
|
|
{
|
|
// verific presenza file log...
|
|
if (!File.Exists(filePath))
|
|
{
|
|
File.WriteAllText(filePath, $"{filePath} created!");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Setup e salvataggio redis delle conf (es modi/stati)
|
|
/// </summary>
|
|
void setupConf()
|
|
{
|
|
// leggo e salvo conf stati
|
|
string fullPath = Path.Combine(confPath, "ConfStatus.json");
|
|
if (File.Exists(fullPath))
|
|
{
|
|
var rawData = File.ReadAllText(fullPath);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
List<MachineStatus>? statusList = JsonConvert.DeserializeObject<List<MachineStatus>>(rawData);
|
|
// salvo in redis!
|
|
redisDb.StringSetAsync(Constants.STATUS_CONF_KEY, JsonConvert.SerializeObject(statusList));
|
|
}
|
|
}
|
|
// leggo e salvo conf modi
|
|
fullPath = Path.Combine(confPath, "ConfMode.json");
|
|
if (File.Exists(fullPath))
|
|
{
|
|
var rawData = File.ReadAllText(fullPath);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
var localObj = JsonConvert.DeserializeObject<List<MachineMode>>(rawData);
|
|
// salvo in redis!
|
|
redisDb.StringSetAsync(Constants.MODE_CONF_KEY, JsonConvert.SerializeObject(localObj));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua log INFO su file e se richiesto su console
|
|
/// </summary>
|
|
void logInfo(string msg, bool log2file = true, bool log2console = false)
|
|
{
|
|
if (log2console)
|
|
{
|
|
Console.WriteLine(msg);
|
|
}
|
|
if (log2file)
|
|
{
|
|
Log.Info(msg);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Effettua log ERROR su file e se richiesto su console
|
|
/// </summary>
|
|
void logError(string msg, bool log2file = true, bool log2console = false)
|
|
{
|
|
if (log2console)
|
|
{
|
|
Console.WriteLine(msg);
|
|
}
|
|
if (log2file)
|
|
{
|
|
Log.Error(msg);
|
|
}
|
|
}
|
|
|
|
void saveAndSendMessage(string memKey, string value, string notifyChannel, string message)
|
|
{
|
|
// effettuo la scrittura nell'area di memoria indicata SE passato intervallo minimo
|
|
bool doSend = true;
|
|
if (LastSend.ContainsKey(memKey))
|
|
{
|
|
if (DateTime.Now.Subtract(LastSend[memKey]).TotalSeconds < 60)
|
|
{
|
|
doSend = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LastSend.Add(memKey, DateTime.Now);
|
|
}
|
|
if (doSend)
|
|
{
|
|
redisDb.StringSetAsync(memKey, value);
|
|
LastSend[memKey] = DateTime.Now;
|
|
logInfo($"Redis Cache Key: {memKey}");
|
|
}
|
|
//redisDb.SetAdd(memKey, value);
|
|
|
|
// invio notifica tramite il canale richiesto
|
|
sub.Publish(notifyChannel, message);
|
|
if (verboseLog)
|
|
{
|
|
logInfo($"[{notifyChannel}] key: {memKey} | val: {value} | message: {message}");
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
if (!logWriting)
|
|
{
|
|
if (LogSimulator.ContainsKey(notifyChannel))
|
|
{
|
|
LogSimulator[notifyChannel]++;
|
|
}
|
|
else
|
|
{
|
|
LogSimulator.Add(notifyChannel, 1);
|
|
}
|
|
logWriting = true;
|
|
// vedo se loggare...
|
|
DateTime adesso = DateTime.Now;
|
|
if (adesso.Subtract(lastLog).TotalSeconds > 15)
|
|
{
|
|
lastLog = adesso;
|
|
logInfo(lineSep);
|
|
|
|
// lavoro su copia...
|
|
var LogSimulatorCopy = new Dictionary<string, int>(LogSimulator);
|
|
foreach (var item in LogSimulatorCopy)
|
|
{
|
|
logInfo($"Redis mQueue {item.Key,-20}{item.Value,12}");
|
|
}
|
|
logInfo(lineSep);
|
|
}
|
|
logWriting = false;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logError($"ERROR{Environment.NewLine}{ex}");
|
|
}
|
|
}
|
|
}
|
|
|
|
void simAlarms()
|
|
{
|
|
int minPeriod = 5000;
|
|
int maxPeriod = 10000;
|
|
|
|
do
|
|
{
|
|
List<int> currAlarmsVal = new List<int>();
|
|
List<string> activeAlarms = new List<string>();
|
|
//int alarmCode = rand.Next(0, 255);
|
|
int alarmCode = rand.Next(0, 160);
|
|
// se >= 128 --> 0 (no alarm)
|
|
alarmCode = alarmCode <= 127 ? alarmCode : 0;
|
|
currAlarmsVal.Add(alarmCode);
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
if ((alarmCode & (1 << i)) != 0)
|
|
{
|
|
activeAlarms.Add($"Alarm {i:000}");
|
|
}
|
|
}
|
|
string rawDataVal = JsonConvert.SerializeObject(currAlarmsVal);
|
|
string rawData = JsonConvert.SerializeObject(activeAlarms);
|
|
// decodifico allarme e lo trasformo in List<String> + List<int> di allarmi attivi...
|
|
saveAndSendMessage(Constants.ALARM_CURR_KEY, rawData, Constants.ALARM_M_QUEUE, rawData);
|
|
saveAndSendMessage(Constants.ALARM_ACT_KEY, rawDataVal, Constants.ALARM_ACT_VAL, rawDataVal);
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simParameters()
|
|
{
|
|
int minPeriod = 150;
|
|
int maxPeriod = 500;
|
|
|
|
do
|
|
{
|
|
var newParams = currSimGen.getParameters();
|
|
string rawData = JsonConvert.SerializeObject(newParams);
|
|
saveAndSendMessage(Constants.PARAMS_CURR_KEY, rawData, Constants.PARAMS_M_QUEUE, rawData);
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simStatus()
|
|
{
|
|
int minPeriod = 1000;
|
|
int maxPeriod = 5000;
|
|
|
|
do
|
|
{
|
|
// recupero uno stato simulato
|
|
var newStatus = currSimGen.getStatus();
|
|
string rawData = JsonConvert.SerializeObject(newStatus);
|
|
saveAndSendMessage(Constants.STATUS_CURR_KEY, rawData, Constants.STATUS_M_QUEUE, rawData);
|
|
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simProd()
|
|
{
|
|
int minPeriod = 3000;
|
|
int maxPeriod = 10000;
|
|
|
|
do
|
|
{
|
|
// recupero uno stato simulato
|
|
var newStatus = currSimGen.getProd();
|
|
string rawData = JsonConvert.SerializeObject(newStatus);
|
|
saveAndSendMessage(Constants.PROD_CURR_KEY, rawData, Constants.PROD_M_QUEUE, rawData);
|
|
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simMachStat()
|
|
{
|
|
int minPeriod = 5000;
|
|
int maxPeriod = 15000;
|
|
|
|
do
|
|
{
|
|
// recupero uno stato simulato
|
|
var newVal = currSimGen.getProdStats();
|
|
string rawData = JsonConvert.SerializeObject(newVal);
|
|
saveAndSendMessage(Constants.MACH_STATS_CURR_KEY, rawData, Constants.MACH_STATS_M_QUEUE, rawData);
|
|
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simMaint()
|
|
{
|
|
int minPeriod = 10000;
|
|
int maxPeriod = 20000;
|
|
|
|
do
|
|
{
|
|
// recupero uno stato simulato
|
|
var newVal = currSimGen.getMaint();
|
|
string rawData = JsonConvert.SerializeObject(newVal);
|
|
saveAndSendMessage(Constants.MAINT_STATS_CURR_KEY, rawData, Constants.MAINT_STATS_M_QUEUE, rawData);
|
|
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simTools()
|
|
{
|
|
int minPeriod = 3000;
|
|
int maxPeriod = 10000;
|
|
|
|
do
|
|
{
|
|
// recupero uno stato simulato
|
|
var newVal = currSimGen.getTools();
|
|
string rawData = JsonConvert.SerializeObject(newVal);
|
|
saveAndSendMessage(Constants.TOOLS_CURR_KEY, rawData, Constants.TOOLS_M_QUEUE, rawData);
|
|
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simEvents()
|
|
{
|
|
int minPeriod = 200;
|
|
int maxPeriod = 800;
|
|
|
|
do
|
|
{
|
|
// recupero uno stato simulato
|
|
var newVal = currSimGen.getEvents();
|
|
string rawData = JsonConvert.SerializeObject(newVal);
|
|
saveAndSendMessage(Constants.EVENT_LOG_CURR_KEY, rawData, Constants.EVENT_LOG_M_QUEUE, rawData);
|
|
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
}
|
|
|
|
void simActivityLog()
|
|
{
|
|
int minPeriod = 15000;
|
|
int maxPeriod = 30000;
|
|
|
|
do
|
|
{
|
|
// recupero uno stato simulato
|
|
var newVal = currSimGen.getActLog();
|
|
string rawData = JsonConvert.SerializeObject(newVal);
|
|
saveAndSendMessage(Constants.ACT_LOG_CURR_KEY, rawData, Constants.ACT_LOG_M_QUEUE, rawData);
|
|
|
|
// attesa random
|
|
Thread.Sleep(rand.Next(minPeriod, maxPeriod));
|
|
} while (true);
|
|
} |