private byte[] recCommFromServer()
{
byte[] res = new byte[commLength];
try
{
serverStream.Read(res, 0, res.Length);
}
catch (Exception e) when(e is IOException || e is ObjectDisposedException)
{
//L'oggetto Socket sottostante è chiuso.
//-oppure -
//La classe NetworkStream è chiusa.
//-oppure -
//Si è verificato un errore durante la lettura dalla rete.
MyLogger.print("Errore nella comunicazione con il server");
MyLogger.debug(e.ToString());
throw new SocketException();
//mainWindow.
}
catch (Exception e)
{
MyLogger.debug(e.ToString());
throw;
}
return(res);
}
/// <summary>
/// delegato che inserisce il file in questione nell'appropriato hashSet
/// </summary>
/// <param name="fi"></param>
private void checkFile(System.IO.FileInfo fi)
{
//MyLogger.add(fi.Name + "\n");
RecordFile thisFile = new RecordFile(fi);
if (fi.Length == 0)
{
return;
}
FileStatus status = dim.UpdateStatus(thisFile);
switch (status)
{
case FileStatus.New:
MyLogger.print("nuovo: ");
newFiles.Add(thisFile);
MyLogger.print(fi.Name + "\n");
break;
case FileStatus.Updated:
MyLogger.print("aggiornato: ");
updatedFiles.Add(thisFile);
MyLogger.print(fi.Name + "\n");
break;
case FileStatus.Old:
MyLogger.debug("vecchio: ");
MyLogger.debug(fi.Name + "\n");
//nothing to do
break;
}
//MyLogger.add(thisFile);
}
public RecoverInfos askForRecoverInfo()
{
//todo: remove
if (DEBUGGING_NO_SERVER)
{
RecoverInfos risdbg = new RecoverInfos();
risdbg.addRawRecord("C:\\DATI\\poli\\Programmazione di Sistema\\progetto_client\\cartella_test\\1\r\n000000111111111100000000000000000000000000000000", 1);
risdbg.addRawRecord("C:\\DATI\\poli\\Programmazione di Sistema\\progetto_client\\cartella_test\\2\r\n000000111111111100000000000000000000000000000000", 2);
risdbg.addRawRecord("C:\\DATI\\poli\\Programmazione di Sistema\\progetto_client\\cartella_test\\3\r\n000000111111111100000000000000000000000000000000", 3);
risdbg.addRawRecord("C:\\DATI\\poli\\Programmazione di Sistema\\progetto_client\\cartella_test\\4\r\n000000111111111100000000000000000000000000000000", 4);
risdbg.addRawRecord("C:\\DATI\\poli\\Programmazione di Sistema\\progetto_client\\cartella_test\\5\r\n000000111111111100000000000000000000000000000000", 5);
risdbg.addRawRecord("C:\\DATI\\poli\\Programmazione di Sistema\\progetto_client\\cartella_test\\6\r\n000000111111111100000000000000000000000000000000", 5);
risdbg.addRawRecord("C:\\DATI\\poli\\Programmazione di Sistema\\progetto_client\\cartella_test\\7\r\n000000111111111100000000000000000000000000000000", 7);
risdbg.addRawRecord("percorso\r\n000000111111111100000000000000000000000000000000", 1);
return(risdbg);
}
//*/
sendToServer(commRecoverInfo);
waitForAck(commCmdAckFromServer);
RecoverInfos ris = new RecoverInfos();
try
{
//leggi numero di versioni
int numVers = Convert.ToInt32(socketReadline());
if (numVers == 0)
{
MyLogger.debug("primo backup necessario");
return(null);
}
int nFile;
int nVersCurr;
//per ogni versione
for (int bv = 1; bv <= numVers; bv++)
{
nVersCurr = Convert.ToInt32(socketReadline());
if (nVersCurr != bv)
{
throw new Exception("nVersCurr != bv !!!!");
}
nFile = Convert.ToInt32(socketReadline());
//per ogni file
for (int f = 0; f < nFile; f++)
{
// [Percorso completo]\r\n[Ultima modifica -> 16byte][Hash -> 32char]\r\n
ris.addRawRecord(socketReadline() + "\r\n" + socketReadline(), bv);
sendToServer(commDataRec);
}
}
}
catch (Exception e)
{
MyLogger.debug("errore in askForRecoverInfo\n");
MyLogger.debug(e.ToString());
throw;
}
return(ris);
}
private void deleteFile(string fileName)
{
try
{
File.Delete(fileName);
}
catch (Exception e)
{
MyLogger.print("impossibile eliminare il file errato: " + fileName);
MyLogger.debug(e);
}
}
private void setAutoSync(bool autoSync)
{
if (autoSync)
{
buttStartStopAutoSync.Content = AUTOSYNC_ON_TEXT;
SyncTimer.Start();
MyLogger.debug("AutoSync attivato\n");
}
else
{
buttStartStopAutoSync.Content = AUTOSYNC_OFF_TEXT;
SyncTimer.Stop();
MyLogger.debug("AutoSync disattivato\n");
}
}
internal void syncNewFiles(RecordFile rf)
{
MyLogger.debug("newing file: " + rf.nameAndPath);
sendToServer(commNewFile);
waitForAck(commCmdAckFromServer);
//aspettare eventuale MISS_BCK o BACKUPOK
if (strRecCommFromServer() == commBackupOkFromServer)
{
SendWholeFileToServer(rf);
MyLogger.debug("newed\n");
}
else
{
throw new AckErrorException();
}
}
public bool setRootFolder(string rootFolder)
{
this.rootFolder = utf8.GetBytes(rootFolder);
sendToServer(commSetFold_str);
waitForAck(commCmdAckFromServer);
sendToServer(this.rootFolder);
if (strRecCommFromServer().Equals(commFolderOk)) //dovrebbe ricevere sempre FOLDEROK
{
MyLogger.debug("cartella selezionata correttamente.\n");
return(true);
}
else
{
throw new UnknownServerResponseException();
}
}
private void textBoxPorta_LostFocus(object sender, RoutedEventArgs e)
{
int res;
try
{
res = Int32.Parse(textBoxPorta.Text);
}
catch (FormatException fe)
{
MyLogger.debug(fe.ToString());
settings.setPorta(0); //valore non valido, con il get sarà restituito il default
textBoxPorta.Text = settings.getPorta().ToString();
return;
}
settings.setPorta(res);
}
private void textboxCycleTime_LostFocus(object sender, RoutedEventArgs e)
{
double num;
string text = textboxCycleTime.Text;
text = text.Replace(".", ",");
if (!Double.TryParse(text, out num))
{
//errore
settings.setCycleTime(0); //numero non valido, verrà restituito il DEFAULT al prossimo get
}
else
{
settings.setCycleTime(num);
}
applyScanInterval(settings.getCycleTime());
MyLogger.debug("cycle time = " + settings.getCycleTime());
}
/// <summary>
/// permette al logic thread di procedere
/// </summary>
public void MakeLogicThreadCycle()
{
System.Diagnostics.Debug.Assert(logicThread != null);
if (!logicThread.IsAlive && !TerminateLogicThread)
{
try
{
logicThread.Start();
return;
}
catch (System.Threading.ThreadStateException e)
{
MyLogger.debug(e.ToString());
}
}
CycleNowEventSignaled = true;
CycleNowEvent.Set(); //permette al logicThread di procedere.
}
internal void logout()
{
try
{
sendToServer(commLogout_str);
MyLogger.print("disconnessione in corso...");
//todo: da qui esce una socketexception da catchare
waitForAck(commCmdAckFromServer);
MyLogger.print("disconnessione effettuata\n");
mainWindow.logged = false;
}
catch (Exception e)
{
MyLogger.debug(e);
}
}
private void sendFileContent(RecordFile f)
{
try
{
const int bufsize = 1024;
var buffer = new byte[bufsize];
int actuallyRead = 0;
long sizeFile = 0;
long totalBytesRead = 0;
long nextStep = 0;
long stepSize;
using (var s = File.OpenRead(f.nameAndPath))
{
sizeFile = s.Length;
stepSize = (long)Math.Ceiling((double)sizeFile / 10);
while ((actuallyRead = s.Read(buffer, 0, bufsize)) > 0)
{
serverStream.Write(buffer, 0, actuallyRead);
//aggiorna progress bar
totalBytesRead += actuallyRead;
if (totalBytesRead > nextStep)
{
mainWindow.Dispatcher.BeginInvoke(mainWindow.DelSetProgressValues, sizeFile, 0, totalBytesRead);
nextStep += stepSize;
}
}
}
serverStream.Flush();
mainWindow.Dispatcher.BeginInvoke(mainWindow.DelSetProgressValues, sizeFile, 0, sizeFile);
}
catch (Exception ex)
{
MyLogger.debug(ex.ToString());
MyLogger.print("errore leggendo il file");
throw;
}
}
internal void syncDeletedFile(RecordFile rf)
{
MyLogger.debug("deleting file: " + rf.nameAndPath);
sendToServer(commDeleteFile);
waitForAck(commCmdAckFromServer);
sendToServer(rf.nameAndPath);
waitForAck(commInfoAckFromServer);
MyLogger.debug("deleted\n");
string res = strRecCommFromServer();
if (res == commDELETED)
{
MyLogger.debug("deleted\n");
}
if (res == commNOTDEL)
{
MyLogger.debug("file inesistente.\n");
}
}
public void sendInitialBackup(List <RecordFile> RecordFileList)
{
//TODO! nota: durante l'upload di un file grosso deve aspettare la fine dell'upload per chiudersi.
//forse è meglio che il main process non faccia join ma si chiuda brutalmente?
sendToServer(commInitialBackup);
waitForAck(commCmdAckFromServer);
MyLogger.print("Primo Backup in corso...");
foreach (var rf in RecordFileList)
{
if (mainWindow.shouldIClose())
{
throw new AbortLogicThreadException();
}
MyLogger.debug("invio del file " + rf.nameAndPath);
sendToServer(commIBNextFile);
SendWholeFileToServer(rf);
MyLogger.debug("completato\n");
}
sendToServer(commIBSyncEnd);
MyLogger.print("Primo Backup eseguito con successo\n");
}
private void newConnection()
{
MyLogger.print("Tentativo di connessione in corso...");
try
{
//se già connesso abort del thread logico
if (clientSocket.Connected)
{
throw new DoubleConnectionException();
}
//System.Net.IPAddress address = System.Net.IPAddress.Parse(serverIP);
clientSocket.Connect(serverIP, serverPort);
serverStream = clientSocket.GetStream();
serverStream.ReadTimeout = cnstReadTimeout;
}
catch (SocketException se)
{
MyLogger.print("Collegamento al server fallito\n");
MyLogger.debug(se);
throw;
}
MyLogger.print("Connesso\n");
}
public MainWindow()
{
//init UI
InitializeComponent();
//init delegates
DelWriteLog = writeInLog_RichTextBox;
DelAskNewAccount = askNewAccount;
DelSetRecoverInfos = setRecoverInfos;
DelSetInterfaceLoggedMode = SetInterfaceLoggedMode;
//DelYesNoQuestion = AskYesNoQuestion;
DelShowOkMsg = ShowOkMsg;
DelSetProgressValues = SetProgressValues;
//init accessory classes
MyLogger.init(this);
//load last settings from file
LoadSettings();
this.CycleNowEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
//this.CheckForAbortEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
SyncTimer = new System.Windows.Threading.DispatcherTimer();
SyncTimer.Tick += new EventHandler(SyncTimerHandler);
AbortTimer = new System.Windows.Threading.DispatcherTimer();
AbortTimer.Tick += new EventHandler(AbortTimerHandler);
AbortTimer.Interval = checkForAbortTimeSpan;
ApplySettings();
//imposta modalità interfaccia a not logged
interfaceMode = interfaceMode_t.notLogged;
//let's start
MyLogger.debug("si comincia\n");
}
public static void debug(Object o)
{
MyLogger.debug(o.ToString());
}
/*-------------------------------------------------------------------------------------------------------------*/
/*---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 static void line()
{
MyLogger.debug("-----------------------------------------------\n");
}
internal void AskForSelectedBackupVersion(MainWindow.RecoveringQuery_st recQuery)
{
int version = recQuery.versionToRecover;
MyLogger.print("Ripristino della versione " + recQuery.versionToRecover + "... ");
sendToServer(commRecoverBackup);
waitForAck(commCmdAckFromServer);
//seleziono versione
sendToServer(version.ToString());
int fileCount = recQuery.recInfos.getVersionSpecificCount(version);
try
{
for (int i = 0; i < fileCount; i++)
{
//legge nome del file
string fileName = socketReadline();
string newPathAndName;
//definisce percorso dove salvare il file
if (recQuery.recoveringFolderPath != "")
{
//path da usare: quello specificato da utente
System.Diagnostics.Debug.Assert(fileName.Contains(mainWindow.settings.getRootFolder()));
//elimina la rootFolder. lascia // iniziale
string localPath = fileName.Substring(mainWindow.settings.getRootFolder().Length);
newPathAndName = recQuery.recoveringFolderPath.TrimEnd(Path.AltDirectorySeparatorChar) + localPath;
}
else
{
//path da usare: quello originale del file
newPathAndName = fileName;
}
//apro il file
FileStream fout;
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(newPathAndName));
try
{
fout = new FileStream(newPathAndName, FileMode.Create);
}
catch (Exception e) when(e is IOException || e is UnauthorizedAccessException)
{
//se file è protetto ne crea una copia a fianco
newPathAndName += "-restoredCopy";
fout = new FileStream(newPathAndName, FileMode.Create);
MyLogger.print("Impossibile ripristinare il file " + newPathAndName + ", salvo con suffisso \"restoredCopy\"\n");
}
System.DateTime LastModifyDate;
try
{
LastModifyDate = RecFileContent(newPathAndName, fout);
fout.Close();
FileInfo fi = new FileInfo(newPathAndName);
fi.LastWriteTime = LastModifyDate;
}
catch (CancelFileRequestException)
{
MyLogger.print("Operazione Annullata\n");
fout.Close();
deleteFile(newPathAndName);
return;
}
catch (IOException)
{
MyLogger.popup("Impossibile accedere al file " + newPathAndName + " Operazione interrotta.", MessageBoxImage.Error);
fout.Close();
deleteFile(newPathAndName);
return;
}
}
//mainWindow.Dispatcher.Invoke(mainWindow.DelShowOkMsg, "Ripristino versione completato!", MessageBoxImage.Information);
//MyLogger.print("Ripristino versione " + recQuery.versionToRecover.ToString() + " riuscito");
MyLogger.popup("Ripristino versione " + recQuery.versionToRecover.ToString() + " riuscito", MessageBoxImage.Information);
}
catch (Exception e)
{
MyLogger.print("ripristino fallito");
mainWindow.Dispatcher.Invoke(mainWindow.DelShowOkMsg, "Ripristino versione fallita", MessageBoxImage.Error);
MyLogger.debug(e.ToString());
return;
}
}