eric: comparison Helpviewer/Sync/FtpSyncHandler.py

-:422cc500eef9
+:28e57079dab5
 """
 Module implementing a synchronization handler using FTP.
 """
-from PyQt4.QtCore import pyqtSignal, QUrl, QFile, QIODevice, QTime, QThread, QTimer
+from PyQt4.QtCore import pyqtSignal, QUrl, QIODevice, QTime, QThread, QTimer, QBuffer
 from PyQt4.QtNetwork import QFtp, QNetworkProxyQuery, QNetworkProxy, QNetworkProxyFactory
 from .SyncHandler import SyncHandler
 import Helpviewer.HelpWindow
 @signal syncStatus(type_, done, message) emitted to indicate the synchronization
 status (string one of "bookmarks", "history", "passwords" or "useragents",
 boolean, string)
 @signal syncError(message) emitted for a general error with the error message (string)
+@signal syncMessage(message) emitted to send a message about synchronization (string)
 @signal syncFinished(type_, done, download) emitted after a synchronization has
 finished (string one of "bookmarks", "history", "passwords" or "useragents",
 boolean, boolean)
 """
 syncStatus = pyqtSignal(str, bool, str)
 syncError = pyqtSignal(str)
+syncMessage = pyqtSignal(str)
 syncFinished = pyqtSignal(str, bool, bool)
 def __init__(self, parent=None):
 """
 Constructor
 @param parent reference to the parent object (QObject)
 """
 super().__init__(parent)
 self.__state = "idle"
+self.__forceUpload = False
 self.__remoteFiles = {
 "bookmarks": "Bookmarks",
 "history": "History",
 "passwords": "Logins",
 "Remote bookmarks file exists! Syncing local copy..."),
 "RemoteMissing": self.trUtf8(
 "Remote bookmarks file does NOT exists. Exporting local copy..."),
 "LocalMissing": self.trUtf8(
 "Local bookmarks file does NOT exist. Skipping synchronization!"),
+"Uploading": self.trUtf8("Uploading local bookmarks file..."),
 },
 "history": {
 "RemoteExists": self.trUtf8(
 "Remote history file exists! Syncing local copy..."),
 "RemoteMissing": self.trUtf8(
 "Remote history file does NOT exists. Exporting local copy..."),
 "LocalMissing": self.trUtf8(
 "Local history file does NOT exist. Skipping synchronization!"),
+"Uploading": self.trUtf8("Uploading local history file..."),
 },
 "passwords": {
 "RemoteExists": self.trUtf8(
 "Remote logins file exists! Syncing local copy..."),
 "RemoteMissing": self.trUtf8(
 "Remote logins file does NOT exists. Exporting local copy..."),
 "LocalMissing": self.trUtf8(
 "Local logins file does NOT exist. Skipping synchronization!"),
+"Uploading": self.trUtf8("Uploading local logins file..."),
 },
 "useragents": {
 "RemoteExists": self.trUtf8(
 "Remote user agent settings file exists! Syncing local copy..."),
 "RemoteMissing": self.trUtf8(
 "Remote user agent settings file does NOT exists."
 " Exporting local copy..."),
 "LocalMissing": self.trUtf8(
 "Local user agent settings file does NOT exist."
 " Skipping synchronization!"),
+"Uploading": self.trUtf8("Uploading local user agent settings file..."),
 },
 }
-def initialLoadAndCheck(self):
+def initialLoadAndCheck(self, forceUpload):
 """
 Public method to do the initial check.
+@keyparam forceUpload flag indicating a forced upload of the files (boolean)
 """
 if not Preferences.getHelp("SyncEnabled"):
 return
 self.__state = "initializing"
+self.__forceUpload = forceUpload
 self.__remoteFilesFound = []
 self.__syncIDs = {}
 self.__idleTimer = QTimer(self)
 elif self.__ftp.currentCommand() == QFtp.Cd:
 self.__ftp.mkdir(self.__storePathList[0])
 self.__ftp.cd(self.__storePathList[0])
 else:
 if id in self.__syncIDs:
+# TODO: change this like below
 self.__syncIDs[id][1].close()
 self.syncStatus.emit(self.__syncIDs[id][0], False,
 self.__ftp.errorString())
 self.syncFinished.emit(self.__syncIDs[id][0], False,
 self.__syncIDs[id][2])
 del self.__syncIDs[id]
+if not self.__syncIDs:
+self.__state = "idle"
+self.syncMessage.emit(self.trUtf8("Synchronization finished"))
 else:
 if self.__ftp.currentCommand() == QFtp.Login:
 self.__changeToStore()
 elif self.__ftp.currentCommand() == QFtp.Cd:
 del self.__storePathList[0]
 self.__storeReached()
 elif self.__ftp.currentCommand() == QFtp.List:
 self.__initialSync()
 else:
 if id in self.__syncIDs:
-self.__syncIDs[id][1].close()
+if self.__ftp.currentCommand() == QFtp.Get:
+self.__syncIDs[id][1].close()
+ok, error = self.writeFile(self.__syncIDs[id][1].buffer(),
+self.__syncIDs[id][3])
+if ok:
+self.syncStatus.emit(self.__syncIDs[id][0], True,
+self.__messages[self.__syncIDs[id][0]]["RemoteExists"])
+else:
+self.syncStatus.emit(self.__syncIDs[id][0], False,
+error)
 self.syncFinished.emit(self.__syncIDs[id][0], True,
 self.__syncIDs[id][2])
 del self.__syncIDs[id]
+if not self.__syncIDs:
+self.__state = "idle"
+self.syncMessage.emit(self.trUtf8("Synchronization finished"))
 def __storeReached(self):
 """
 Private slot executed, when the storage directory was reached.
 """
 """
 if info.isValid() and info.isFile():
 if info.name() in self.__remoteFiles.values():
 self.__remoteFilesFound.append(info.name())
+def __downloadFile(self, type_, fileName):
+"""
+Private method to downlaod the given file.
+@param type_ type of the synchronization event (string one
+of "bookmarks", "history", "passwords" or "useragents")
+@param fileName name of the file to be downloaded (string)
+"""
+buffer = QBuffer(self)
+buffer.open(QIODevice.WriteOnly)
+id = self.__ftp.get(self.__remoteFiles[type_], buffer)
+self.__syncIDs[id] = (type_, buffer, True, fileName)
+def __uploadFile(self, type_, fileName):
+"""
+Private method to upload the given file.
+@param type_ type of the synchronization event (string one
+of "bookmarks", "history", "passwords" or "useragents")
+@param fileName name of the file to be uploaded (string)
+"""
+data = self.readFile(fileName)
+if data.isEmpty():
+self.syncStatus.emit(type_, True,
+self.__messages[type_]["LocalMissing"])
+else:
+id = self.__ftp.put(data, self.__remoteFiles[type_])
+self.__syncIDs[id] = (type_, data, False)
 def __initialSyncFile(self, type_, fileName):
 """
 Private method to do the initial synchronization of the given file.
 @param type_ type of the synchronization event (string one
 of "bookmarks", "history", "passwords" or "useragents")
 @param fileName name of the file to be synchronized (string)
 """
-f = QFile(fileName)
+if not self.__forceUpload and \
-if self.__remoteFiles[type_] in self.__remoteFilesFound:
+self.__remoteFiles[type_] in self.__remoteFilesFound:
+self.__downloadFile(type_, fileName)
+else:
 self.syncStatus.emit(type_, True,
-self.__messages[type_]["RemoteExists"])
+self.__messages[type_]["RemoteMissing"])
-f.open(QIODevice.WriteOnly)
+self.__uploadFile(type_, fileName)
-id = self.__ftp.get(self.__remoteFiles[type_], f)
-self.__syncIDs[id] = (type_, f, True)
-else:
-if f.exists():
-self.syncStatus.emit(type_, True,
-self.__messages[type_]["RemoteMissing"])
-f.open(QIODevice.ReadOnly)
-id = self.__ftp.put(f, self.__remoteFiles[type_])
-self.__syncIDs[id] = (type_, f, False)
-else:
-self.syncStatus.emit(type_, True,
-self.__messages[type_]["LocalMissing"])
 def __initialSync(self):
 """
 Private slot to do the initial synchronization.
 """
 # User Agent Settings
 if Preferences.getHelp("SyncUserAgents"):
 self.__initialSyncFile("useragents",
 Helpviewer.HelpWindow.HelpWindow.userAgentsManager().getFileName())
+self.__forceUpload = False
 def __syncFile(self, type_, fileName):
 """
 Private method to synchronize the given file.
 @param type_ type of the synchronization event (string one
 of "bookmarks", "history", "passwords" or "useragents")
 @param fileName name of the file to be synchronized (string)
 """
+if self.__state == "initializing":
+return
 self.__state = "uploading"
-f = QFile(fileName)
+self.syncStatus.emit(type_, True, self.__messages[type_]["Uploading"])
-if f.exists():
+self.__uploadFile(type_, fileName)
-f.open(QIODevice.ReadOnly)
-id = self.__ftp.put(f, self.__remoteFiles[type_])
-self.__syncIDs[id] = (type_, f, False)
 def syncBookmarks(self):
 """
 Public method to synchronize the bookmarks.
 """

Mercurial Repositories > eric / file comparison

comparison: Helpviewer/Sync/FtpSyncHandler.py

Helpviewer/Sync/FtpSyncHandler.py