/// <summary>
/// costruttore
/// </summary>
/// <param name="path">path della cartella da monitorare</param>
public DirMonitor(string path, SessionManager sm)
{
myDir = new System.IO.DirectoryInfo(path);
if (!myDir.Exists)
throw new System.IO.DirectoryNotFoundException(path);
try
{
dim = new DirImageManager(myDir, sm);
}
catch(InitialBackupNeededException ibne)
{
//TODO! ATTENZIONE, COME INTERROMPO L'APPLICAZIONE METRE STA FACENDO L'INITIAL BACKUP ????? al momento solo tra un file e l'altro
//non c'è ancora nessun backup sul server, impossibile scaricare una dirImage.
//devo fare un initial backup completo. terminato quello bisogna riscaricare la dirImage
completeFileList = new List<RecordFile>();
//salvo vecchio delegato
var buf = this.doOnFile;
this.doOnFile = addAllFiles;
//crea elenco completo file in root dir e subdirs
WalkDirectoryTree(myDir, doOnFile);
//rimetto delegato di prima
this.doOnFile = buf;
//effettua backup completo di tutti i file
sm.sendInitialBackup(completeFileList);
completeFileList = null;
//se la cartella è vuota la new DirImageManager continua a fallire, viene rilanciata l'eccezione InitialBackupNeededException
try
{
//riscarico la dirImage
dim = new DirImageManager(myDir, sm);
}
catch (InitialBackupNeededException) { throw new EmptyDirException(); }
}
doOnFile = checkFile;
init();
}
/*-------------------------------------------------------------------------------------------------------------*/
/*---logic Tread methods---------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------*/
//siamo nel secondo thread, quello che non gestisce la interfaccia grafica.
private void logicThreadStart()
{
MyLogger.debug("LogicThread starting");
//setto interfaccia a busy
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.busy);
try //catch errori non recuperabili per il thread
{
//reset richieste eventualmente vecchie per il logic thread
resetLogicThreadNeeds();
//avvio tmer per verifica abort signals periodicamente
AbortTimer.Start();
//inizializzo oggetto per connessione con server
sm = new SessionManager(settings.getIP(), settings.getPorta(), this);
//bool connected = false;
//gestione del login
sm.login(settings.getUser(), settings.getPassw());
logged = true;
//selezione cartella
sm.setRootFolder(settings.getRootFolder());
//attiva modalità logged nella UI
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.logged);
//voglio iniziare con una sync
needToSync = true;
//needToSync = false;
//è la prima sync per questa connessione
firstConnSync = true;
//firstConnSync = false;
//ciclo finchè la connessione è attiva. si esce solo con eccezione o con chiusura thread logico (anch'essa un'eccezione).
while (true)
{
//verifica se deve sincronizzare
if (needToSync)
{
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.busy);
MyLogger.print("AutoSync in corso\n");
// se è la prima sincronizzazione di questa connessione al server, crea DirMonitor
if (firstConnSync)
{
firstConnSync = false;
try
{
//init del dirMonitor
d = new DirMonitor(settings.getRootFolder(), sm);
}
catch (EmptyDirException)
{
//se arrivo qui è perchè c'è stata la prima connessione, l'initial backup di una cartella vuota e il download delle recoverInfo sempre vuote.
firstConnSync = true;
}
}
else //non è la prima connessione
{
//scandisco root folder
d.scanDir();
//sincronizzo tutte le modifiche
SyncAll();
}
needToSync = false;
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.logged);
MyLogger.print("Completata\n");
}
//verifica se deve richiedere l'intero ultimo backup
if (needToRecoverWholeBackup)
{
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.busy);
sm.AskForSelectedBackupVersion(RecoveringQuery);
needToRecoverWholeBackup = false;
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.logged);
}
//verifica se deve richiedere dati per ripristino di file vecchi
if (needToAskRecoverInfo)
{
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.busy);
var recInfos = sm.askForRecoverInfo();
needToAskRecoverInfo = false;
System.Diagnostics.Debug.Assert(recoverW != null);
recoverW.Dispatcher.Invoke(DelSetRecoverInfos, recInfos);
//qui l'interfaccia sarà resettata dalla recoverwindow che si chiude
//this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.logged);
}
//recupera recoverRecord
if (needToAskForFileToRecover)
{
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.busy);
//recupera file
sm.askForSingleFile(fileToRecover);
needToAskForFileToRecover = false;
this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.logged);
}
WaitForSyncTime();
}
} //fine try esterno
catch (SocketException)
{
MyLogger.print("impossibile connettersi. Server non ragiungibile");
}
catch (LoginFailedException)
{
MyLogger.print("errore nel login. Correggere dati di accesso o creare nuovo utente.");
}
catch (RootSetErrorException)
{
MyLogger.print("errore nella selezione della cartella. Correggere il path");
}
catch (AbortLogicThreadException)
{
MyLogger.print("Connessione Interrotta\n");
MyLogger.debug("LogicThread closing per abort logic thread exception");
}
catch(DirectoryNotFoundException)
{
MyLogger.print("impossibile trovare directory specificata. Selezionarne un'altra");
}
catch (Exception e) //eccezione sconosciuta.
{
MyLogger.line();
MyLogger.debug(e.Message);
MyLogger.line();
MyLogger.debug(e.ToString());
MyLogger.debug("LogicThread closing");
MyLogger.print("Errore sconosciuto. Chiusura connessione.\n");
}
this.Dispatcher.BeginInvoke(DelSetInterfaceLoggedMode, interfaceMode_t.notLogged);
//if (!TerminateLogicThread)
//{
// //setta la UI in modalità unlocked a meno che non sia TerminateLogicThread settata,
// //se no mainThread va in join e va in deadlock (non esegue invoke())
// this.Dispatcher.BeginInvoke(DelSetInterfaceLoggedMode, interfaceMode_t.notLogged);
//}
sm.closeConnection();
//disattivo il timer che sblocca periodicamente il logicThread affinchè controlli se deve abortire
AbortTimer.Stop();
//this.Dispatcher.Invoke(DelSetInterfaceLoggedMode, interfaceMode_t.notLogged);
logged = false;
//TODO: ma quando chiudo recoverW diventa null?
if (recoverW != null)
recoverW.Dispatcher.BeginInvoke(recoverW.DelCloseWindow);
return; //logic thread termina qui
}
public DirImageManager(System.IO.DirectoryInfo myDir, SessionManager sm)
{
this.myDir = myDir;
dirImage = new Dictionary<string, RecordFile>();
loadDirImage(sm);
}
private void loadDirImage(SessionManager sm)
{
RecoverInfos recInfo;
//richiede al server le info di recover
recInfo = sm.askForRecoverInfo();
//se il server non ha nessuna informazione
if (recInfo == null)
{
//dirImage resta vuota
throw new InitialBackupNeededException();
}
//tiene solo ultima versione (stato attuale cartella su server)
List<RecoverRecord> lastVersionInfos = recInfo.getVersionSpecificRecoverList(recInfo.getLastBackupVersionNumber());
foreach (var rr in lastVersionInfos)
{
dirImage.Add(rr.rf.nameAndPath, rr.rf);
}
}