Esempio n. 1
0
        /// <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();
        }
Esempio n. 2
0
        /*-------------------------------------------------------------------------------------------------------------*/
        /*---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
        }
Esempio n. 3
0
 public DirImageManager(System.IO.DirectoryInfo myDir, SessionManager sm)
 {
     this.myDir = myDir;
     dirImage = new Dictionary<string, RecordFile>();
     loadDirImage(sm);
 }
Esempio n. 4
0
        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);
            }
        }