void ProcessTimer(object unused)
{
m_timer.Change(Timeout.Infinite, Timeout.Infinite);
var netEngin = new NetEngin(Program.NetworkSettings);
string tmpFile = Path.GetTempFileName();
netEngin.Download(tmpFile, Urls.ConnectionRespURL, true);
var seq = from msg in DialogEngin.ReadConnectionsResp(tmpFile)
where msg.ReqID >= m_lastMsgID
select msg;
if (!seq.Any())
{
m_timer.Change(Timeout.Infinite, Timeout.Infinite);
}
else
{
Message resp = (from msg in seq
where msg.ReqID == m_lastMsgID
select msg).SingleOrDefault();
if (resp == null)
{
PostReqAsync();
}
else
{
switch (resp.MessageCode)
{
case Message_t.Ok:
//reset dlg file
try
{
string dlgFile = SettingsManager.GetClientDialogFilePath(m_clientID);
DialogEngin.WriteHubDialog(dlgFile, m_clientID, Enumerable.Empty <Message>());
netEngin.Upload(SettingsManager.GetClientDialogURL(m_clientID), dlgFile, true);
m_callback(Result_t.Ok);
}
catch (Exception ex)
{
Dbg.Log(ex.Message);
PostReqAsync();
}
break;
case Message_t.InvalidID:
case Message_t.Rejected:
m_callback(Result_t.Rejected);
break;
default:
Dbg.Assert(false);
break;
}
}
}
}
void ProcessResp()
{
StopTimer();
string tmpFile = Path.GetTempFileName();
Dbg.Log($"Processing Response, attempts = {m_attemptsCount + 1}.");
m_exHandler = RespExceptionHandler;
var netEngin = new NetEngin(Program.NetworkSettings);
using (new AutoReleaser(() => File.Delete(tmpFile)))
{
SetProgressMessage("Réception des données à partir du serveur...");
try
{
netEngin.Download(tmpFile, Urls.ConnectionRespURL, true);
}
catch (Exception ex)
{
Dbg.Log(ex.Message);
DialogEngin.WriteConnectionsResp(tmpFile, Enumerable.Empty <HubCore.DLG.Message>());
}
IEnumerable <HubCore.DLG.Message> messages = DialogEngin.ReadConnectionsResp(tmpFile);
HubCore.DLG.Message[] msgs = (from resp in messages
where resp.ReqID >= m_msgID
select resp).ToArray();
HubCore.DLG.Message msg = msgs.Where(m => m.ReqID == m_msgID).SingleOrDefault();
uint clID = msg == null ? 0 : BitConverter.ToUInt32(msg.Data, 0);
if (msg != null && clID == m_clInfo.ClientID)
{
switch (msg.MessageCode)
{
case Message_t.InvalidID:
Dbg.Log($"Got invalid ID! (ClientID = {m_clInfo.ClientID}).");
ClientInfo clInfo = ClientInfo.CreateClient(m_clInfo.ProfileID);
clInfo.ContaclEMail = m_clInfo.ContaclEMail;
clInfo.ContactName = m_clInfo.ContactName;
clInfo.ContactPhone = m_clInfo.ContactPhone;
m_clInfo = clInfo;
if (++m_attemptsCount >= SettingsManager.MaxConnectAttemps)
{
if (ShowMessage(MAX_ATTEMPTS_ERROR, MessageBoxButtons.YesNo) != DialogResult.Yes)
{
CloseDialog();
return;
}
else
{
m_attemptsCount = 0;
}
}
PostReq();
break;
case Message_t.Ok:
Dbg.Log("Client registered :-)!");
Program.Settings.ClientInfo = m_clInfo;
SetProgressMessage("Enregistrement terminé.");
//creation des fichier dlg
string dlgFile = SettingsManager.GetClientDialogFilePath(clID);
DialogEngin.WriteHubDialog(dlgFile, clID, Enumerable.Empty <HubCore.DLG.Message>());
try
{
netEngin.Upload(SettingsManager.GetClientDialogURL(clID), dlgFile, true);
}
catch (Exception ex)
{
Dbg.Log(ex.Message);
}
ShowMessage("Votre enregistrement est maintenant terminé. " +
"Vous pouvez commencer à utiliser l’application.");
IsRegistered = true;
CloseDialog();
break;
case Message_t.InvalidProfile:
Dbg.Log($"Got invalid Profile! (ProfileID: = {m_clInfo.ProfileID}).");
ShowMessage(SRV_ERROR);
CloseDialog();
return;
case Message_t.Rejected:
Dbg.Log("Got reject connection!");
ShowMessage(REJECT_CONNCTION_ERROR);
CloseDialog();
return;
default:
Dbg.Log("Got invalid response!!!!");
Dbg.Assert(false);
break;
}
}
else if (msgs.Length > 0)
{
Dbg.Log("Request message lost.");
if (++m_attemptsCount >= SettingsManager.MaxConnectAttemps)
{
if (ShowMessage(MAX_ATTEMPTS_ERROR, MessageBoxButtons.YesNo) != DialogResult.Yes)
{
CloseDialog();
return;
}
else
{
m_attemptsCount = 0;
}
}
PostReq();
}
else if (++m_attemptsCount >= SettingsManager.MaxConnectAttemps)
{
Dbg.Log("Timeout.");
if (ShowMessage(MAX_ATTEMPTS_ERROR, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
StartTimer();
m_attemptsCount = 0;
PostReq();
}
else
{
CloseDialog();
}
}
else
{
StartTimer();
SetProgressMessage("Attente de la réponse du serveur...");
}
}
}
Message ProcessStartMessage(Message msg)
{
Dbg.Assert(msg.MessageCode == Message_t.Start);
var reader = new RawDataReader(new MemoryStream(msg.Data), Encoding.UTF8);
uint clID = reader.ReadUInt();
ClientEnvironment clEnv = ClientEnvironment.Load(reader);
DateTime dtStart = reader.ReadTime();
var client = m_ndxerClients.Get(clID) as HubClient;
if (client == null)
{
AppContext.LogManager.LogSysActivity("Réception d’une notification de démarrage " +
$"de la part d’un client inexistant ({ClientStrID(clID)}). Réinitialisation du client", true);
//maj du fichier gov
string srvDlgFile = AppPaths.GetSrvDialogFilePath(clID);
//le client n'existe pas => son fichier gov n'existe pas
var clDlg = new ClientDialog(clID, ClientStatus_t.Reseted, Enumerable.Empty <Message>());
DialogEngin.WriteSrvDialog(srvDlgFile, clDlg);
AddUpload(Path.GetFileName(srvDlgFile));
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Rejected, msg.Data));
}
AppContext.LogManager.LogSysActivity("Réception d’une notification de démarrage " +
$"de la part du client {ClientStrID(clID)}", true);
//verifier le statut du client
var clStatus = m_ndxerClientsStatus.Get(clID) as ClientStatus;
if (clStatus.Status != ClientStatus_t.Enabled)
{
AppContext.LogManager.LogSysActivity($"Démmarage du Client { ClientStrID(clID)} non autorisé. Requête rejetée", true);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Rejected, msg.Data));
}
//reset dlg files
DialogEngin.WriteHubDialog(AppPaths.GetClientDilogFilePath(clID), clID, Enumerable.Empty <Message>());
DialogEngin.WriteSrvDialog(AppPaths.GetSrvDialogFilePath(clID),
new ClientDialog(clID, clStatus.Status, Enumerable.Empty <Message>()));
try
{
new NetEngin(AppContext.Settings.NetworkSettings).Upload(Urls.DialogDirURL,
new string[] { AppPaths.GetClientDilogFilePath(clID), AppPaths.GetSrvDialogFilePath(clID) });
}
catch (Exception ex)
{
AppContext.LogManager.LogSysError($"Traitement de la requête de démarrage du client {ClientStrID(clID)}: " +
$"{ ex.Message}. demande ignorée, laisser le client reformuler la requête.", true);
return(null); // let the cleint retry req.
}
AppContext.LogManager.LogSysActivity($"Client {ClientStrID(clID)} démarré le { dtStart.Date.ToShortDateString()} " +
$"à { dtStart.ToLongTimeString()}", true);
//verifier si l'env du client a changé
UpdateClientEnvironment(clID, clEnv);
//ajouter client dans running liste
m_onlineClients.Add(clID, dtStart);
AppContext.LogManager.StartLogger(clID);
AppContext.LogManager.LogClientActivity(clID, "Démarrage");
//maj du last seen
clStatus.LastSeen = dtStart;
m_ndxerClientsStatus.Source.Replace(m_ndxerClientsStatus.IndexOf(clID), clStatus);
ClientStarted?.Invoke(clID);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Ok, msg.Data));
}
Message ProcessNewConnectionReq(Message msg)
{
Dbg.Assert(msg.MessageCode == Message_t.NewConnection);
//TextLogger.Info("Réception d’une nouvelle requête d’inscription.");
var ms = new MemoryStream(msg.Data);
var reader = new RawDataReader(ms, Encoding.UTF8);
ClientInfo clInfo = ClientInfo.LoadClientInfo(reader);
ClientEnvironment clEnv = ClientEnvironment.Load(reader);
byte[] data = BitConverter.GetBytes(clInfo.ClientID);
var profile = m_ndxerProfiles.Get(clInfo.ProfileID) as UserProfile;
string reqLog = $"Réception d'une demande d’inscription émanant de {clInfo.ContactName}" +
$"(ID = {ClientStrID(clInfo.ClientID)}) pour " +
(profile == null ? "un profil inexistant." :
$"le profil {profile.Name}.");
AppContext.LogManager.LogSysActivity(reqLog, true);
//verifier que le profil existe
if (profile == null)
{
AppContext.LogManager.LogSysActivity("Lancement de la procédure d’actualisation " +
"de la liste des profils sur le serveur", true);
ProcessProfilesChange();
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.InvalidProfile, data));
}
//verifier que ClientID n'existe pas
var clSameID = m_ndxerClients.Get(clInfo.ClientID) as HubClient;
if (clSameID != null)
{
AppContext.LogManager.LogSysActivity("Collision d’identifiants: " +
$"un client portant le même ID est déjà enregistré ({clSameID.ContactName}). " +
"Exiger au client de reformuler son inscription avec un nouvel ID", true);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.InvalidID, data));
}
//verifier que le profile est en mode auto
ManagementMode_t prfMgmntMode = GetProfileManagementMode(clInfo.ProfileID);
if (prfMgmntMode == ManagementMode_t.Manual)
{
AppContext.LogManager.LogSysActivity("Profil en gestion manuelle, inscription rejetée.", true);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Rejected, data));
}
TextLogger.Info("Profil en gestion automatique.");
TextLogger.Info("Enregistrement du client...");
//desactiver l'ancien client actif si il existe
var oldClient = GetProfileEnabledClient(clInfo.ProfileID);
if (oldClient != null)
{
if (IsClientRunning(oldClient.ID))
{
//rejeter l'inscription
AppContext.LogManager.LogSysActivity($"Un client pour le profil {profile.Name} est déjà en cours d’exécution. " +
"Inscription rejetée", true);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Rejected, data));
}
AppContext.LogManager.LogSysActivity($"Désactivation du client {ClientStrID(oldClient.ID)}", true);
//maj la table des status clients
var oldClStatus = m_ndxerClientsStatus.Get(oldClient.ID) as ClientStatus;
oldClStatus.Status = ClientStatus_t.Disabled;
int ndx = m_ndxerClientsStatus.IndexOf(oldClStatus.ID);
m_ndxerClientsStatus.Source.Replace(ndx, oldClStatus);
//maj des fichiers de dialogue de old client
string filePath = AppPaths.GetSrvDialogFilePath(oldClient.ID);
ClientDialog clDlg = new ClientDialog(oldClient.ID, ClientStatus_t.Disabled, Enumerable.Empty <Message>());
DialogEngin.WriteSrvDialog(filePath, clDlg);
AddUpload(Names.GetSrvDialogFile(oldClient.ID));
}
//creer le fichier dialogue
string srvDlgPath = AppPaths.GetSrvDialogFilePath(clInfo.ClientID);
DialogEngin.WriteSrvDialog(srvDlgPath, new ClientDialog(clInfo.ClientID,
ClientStatus_t.Enabled, Enumerable.Empty <Message>()));
DialogEngin.WriteHubDialog(AppPaths.GetClientDilogFilePath(clInfo.ClientID),
clInfo.ClientID, Enumerable.Empty <Message>());
try
{
new NetEngin(AppContext.Settings.NetworkSettings).Upload(Urls.DialogDirURL,
new string[] { AppPaths.GetClientDilogFilePath(clInfo.ClientID), AppPaths.GetSrvDialogFilePath(clInfo.ClientID) });
}
catch (Exception ex)
{
AppContext.LogManager.LogSysError($"Traitement de la requête d'inscription du client {ClientStrID(clInfo.ClientID)}: " +
$"{ ex.Message}. demande ignorée, laisser le client reformuler la requête", true);
return(null); // let the cleint retry req.
}
//maj la table des clients
var hClient = new HubClient(clInfo.ClientID, clInfo.ProfileID)
{
ContaclEMail = clInfo.ContaclEMail,
ContactName = clInfo.ContactName,
ContactPhone = clInfo.ContactPhone,
};
m_ndxerClients.Source.Insert(hClient);
//maj du status client
var clStatus = new ClientStatus(clInfo.ClientID, ClientStatus_t.Enabled);
m_ndxerClientsStatus.Source.Insert(clStatus);
//maj du client env
UpdateClientEnvironment(clInfo.ClientID, clEnv);
//maj du dict des clients actifs
m_onlineClients.Add(clInfo.ClientID);
AppContext.LogManager.StartLogger(clInfo.ClientID);
AppContext.LogManager.LogClientActivity(clInfo.ClientID, "Inscription");
ClientStarted?.Invoke(clInfo.ClientID);
AppContext.LogManager.LogSysActivity($"Inscription du client {clInfo.ClientID} terminée", true);
TextLogger.Info("Inscription réussie. :-)");
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Ok, data));
}
Message ProcessResumeConnectionReq(Message msg)
{
Dbg.Assert(msg.MessageCode == Message_t.Resume);
//verfier que le client existe
uint clID = BitConverter.ToUInt32(msg.Data, 0);
var client = m_ndxerClients.Get(clID) as HubClient;
if (client == null)
{
AppContext.LogManager.LogSysActivity("Réception d’une requête de reprise émanant d’un client non enregistré. Réinitialisation du client.", true);
//maj du fichier gov
string srvDlgFile = AppPaths.GetSrvDialogFilePath(clID);
//le client n'existe pas => son fichier gov n'existe pas
var clDlg = new ClientDialog(clID, ClientStatus_t.Reseted, Enumerable.Empty <Message>());
DialogEngin.WriteSrvDialog(srvDlgFile, clDlg);
AddUpload(Path.GetFileName(srvDlgFile));
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Rejected, BitConverter.GetBytes(clID)));
}
var prf = m_ndxerProfiles.Get(client.ProfileID) as UserProfile;
AppContext.LogManager.LogSysActivity($"Requête de reprise émanant de {ClientStrID(clID)} pour le profil " +
$"{prf.Name}, inscrit le {client.CreationTime}", true);
//verifier que le profil est en mode auto
if ((m_ndxerProfilesMgmnt.Get(prf.ID) as ProfileManagementMode).ManagementMode == ManagementMode_t.Manual)
{
AppContext.LogManager.LogSysActivity($"Le profil {prf.Name} est en gestion manuelle. Requête de reprise rejetée", true);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Rejected, msg.Data));
}
//appliquer l'alog. de selction du client
// si date inscription client actif <= date inscription client en pause
// rejeter le demande
//sinon
// bannir le client actif
// acvtiver le client en pause
var curClient = GetProfileEnabledClient(prf.ID) as HubClient;
if (curClient != null)
{
if (curClient.CreationTime <= client.CreationTime)
{
AppContext.LogManager.LogSysActivity($"Le client actif {ClientStrID(curClient.ID)} inscrit le " +
$"{curClient.CreationTime}. Le client actif est plus ancien. Requête de reprise rejetée", true);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Rejected, msg.Data));
}
//bannissemnt du client actif
AppContext.LogManager.LogSysActivity($"Le client actif {ClientStrID(curClient.ID)} inscrit le " +
$"{curClient.CreationTime}. Le client demandeur de reprise est plus ancien. Bannissement du client actif", true);
//maj de la table des statuts
var curClStatus = m_ndxerClientsStatus.Get(curClient.ID) as ClientStatus;
curClStatus.Status = ClientStatus_t.Banned;
int ndxCurClient = m_ndxerClientsStatus.IndexOf(curClStatus.ID);
m_ndxerClientsStatus.Source.Replace(ndxCurClient, curClStatus);
//maj du fichier distant g
string curClFilePath = AppPaths.GetSrvDialogFilePath(curClient.ID);
var curClDlg = new ClientDialog(curClient.ID, ClientStatus_t.Banned, Enumerable.Empty <Message>());
DialogEngin.WriteSrvDialog(curClFilePath, curClDlg);
AddUpload(Names.GetSrvDialogFile(curClient.ID));
}
//activation du client demandeur
//reset dlg files
DialogEngin.WriteHubDialog(AppPaths.GetClientDilogFilePath(clID), clID, Enumerable.Empty <Message>());
DialogEngin.WriteSrvDialog(AppPaths.GetSrvDialogFilePath(clID),
new ClientDialog(clID, ClientStatus_t.Enabled, Enumerable.Empty <Message>()));
try
{
new NetEngin(AppContext.Settings.NetworkSettings).Upload(Urls.DialogDirURL,
new string[] { AppPaths.GetClientDilogFilePath(clID), AppPaths.GetSrvDialogFilePath(clID) });
}
catch (Exception ex)
{
AppContext.LogManager.LogSysError($"Traitement de la requête de reprise du client {ClientStrID(clID)}: " +
$"{ ex.Message}. demande ignorée, laisser le client reformuler la requête", true);
return(null); // let the cleint retry req.
}
//maj de la table des statuts
var clStatus = m_ndxerClientsStatus.Get(clID) as ClientStatus;
clStatus.Status = ClientStatus_t.Enabled;
int ndxClient = m_ndxerClientsStatus.IndexOf(clID);
m_ndxerClientsStatus.Source.Replace(ndxClient, clStatus);
//maj du dic des clients actifs
m_onlineClients.Add(clID);
AppContext.LogManager.StartLogger(clID);
AppContext.LogManager.LogClientActivity(clID, "Reprise.");
ClientStarted?.Invoke(clID);
AppContext.LogManager.LogSysActivity($"Demande de reprise du client {ClientStrID(clID)} acceptée", true);
return(msg.CreateResponse(++m_lastCnxRespMsgID, Message_t.Ok, msg.Data));
}
public void Start()
{
Dbg.Assert(IsRunning == false);
IsRunning = true;
Opts.SettingsView.ClientInfoChanged += SettingsView_ClientInfoChaned;
//client enregistre?
m_clInfo = Program.Settings.ClientInfo;
if (m_clInfo == null)
{
if (RegisterClient())
{
m_clStatus = ClientStatus_t.Enabled;
m_dialogTimer.Start();
m_updateTimer.Start();
m_dialogRunning = true;
var updateTask = new Task(AutoUpdater.Update, TaskCreationOptions.LongRunning);
updateTask.Start();
}
return;
}
DialogEngin.WriteHubDialog(SettingsManager.GetClientDialogFilePath(m_clInfo.ClientID),
m_clInfo.ClientID, Enumerable.Empty <Message>());
//process only status part of the g file
string tmpFile = Path.GetTempFileName();
Action start = () =>
{
var netEngin = new NetEngin(Program.NetworkSettings);
netEngin.Download(tmpFile, SettingsManager.GetServerDialogURL(m_clInfo.ClientID), true);
};
Action onSuccess = () =>
{
ClientDialog clDlg = DialogEngin.ReadSrvDialog(tmpFile);
m_clStatus = clDlg.ClientStatus;
if (m_clStatus == ClientStatus_t.Enabled)
{
new StartHandler(m_clInfo.ClientID, StartResp).Start();
}
else if (m_clStatus == ClientStatus_t.Banned)
{
foreach (IDBTable tbl in Program.TablesManager.CriticalTables)
{
tbl.Clear();
Program.Settings.DataGeneration = 0;
}
System.Windows.Forms.MessageBox.Show(AppText.ERR_BANNED, AppText.APP_NAME,
System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
Exit();
return;
}
else if (m_clStatus == ClientStatus_t.Disabled)
{
new ResumeHandler(ResumeResp, m_clInfo.ClientID).Start();
}
else
{
ResetRegistration();
}
File.Delete(tmpFile);
};
Action <Task> onErr = t =>
{
Dbg.Log(t.Exception.InnerException.Message);
//assume client enabled
m_clStatus = ClientStatus_t.Enabled;
new StartHandler(m_clInfo.ClientID, StartResp).Start();
};
var task = new Task(start, TaskCreationOptions.LongRunning);
task.OnSuccess(onSuccess);
task.OnError(onErr);
task.Start();
}
bool RegisterClient()
{
var busyDlg = new BusyDialog();
busyDlg.Message = "Initialisation...";
Action <Task <IEnumerable <ProfileInfo> > > onSuccess = t => busyDlg.Dispose();
Action <Task> onErr = t =>
{
busyDlg.Dispose();
//System.Windows.Forms.MessageBox.Show(t.Exception.InnerException.Message , null);
};
IEnumerable <ProfileInfo> profiles = null;
var task = new Task <IEnumerable <ProfileInfo> >(() => profiles = Program.DialogManager.Profiles,
TaskCreationOptions.LongRunning);
task.OnSuccess(onSuccess);
task.OnError(onErr);
task.Start();
busyDlg.ShowDialog();
if (profiles == null || !profiles.Any())
{
System.Windows.Forms.MessageBox.Show("Aucune réponse du serveur. Veuillez réessayer ultérieurement.",
AppText.APP_NAME, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
Exit();
return(false);
}
ClientInfo clInfo;
using (var dlg = new ProfileDialog(profiles))
{
if (dlg.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
Exit();
}
clInfo = ClientInfo.CreateClient(dlg.SelectedProfile.ProfileID);
clInfo.ContaclEMail = dlg.ContactEMail;
clInfo.ContactName = dlg.Contact;
clInfo.ContactPhone = dlg.ContactPhone;
}
using (var dlg = new ConnectionDialog(clInfo))
{
dlg.ShowDialog();
if (!dlg.IsRegistered)
{
Exit();
return(false);
}
m_clInfo = Program.Settings.ClientInfo;
DialogEngin.WriteHubDialog(SettingsManager.GetClientDialogFilePath(m_clInfo.ClientID),
m_clInfo.ClientID, Enumerable.Empty <Message>());
}
return(true);
}
