eric: comparison Helpviewer/Sync/FtpSyncHandler.py

-:136eb25e4314
+:5cb87968aad5
 """
 import ftplib
 import io
-from PyQt4.QtCore import pyqtSignal, QUrl, QTimer, QFileInfo, QCoreApplication, QByteArray
+from PyQt4.QtCore import pyqtSignal, QTimer, QFileInfo, QCoreApplication, QByteArray
-from PyQt4.QtNetwork import QNetworkProxyQuery, QNetworkProxy, QAuthenticator
+from E5Network.E5Ftp import E5Ftp, E5FtpProxyType, E5FtpProxyError
-from E5Network.E5NetworkProxyFactory import E5NetworkProxyFactory, \
-proxyAuthenticationRequired
 from .SyncHandler import SyncHandler
 import Helpviewer.HelpWindow
 self.__idleTimer = QTimer(self)
 self.__idleTimer.setInterval(Preferences.getHelp("SyncFtpIdleTimeout") * 1000)
 self.__idleTimer.timeout.connect(self.__idleTimeout)
-self.__ftp = ftplib.FTP()
+self.__ftp = E5Ftp()
 # do proxy setup
-self.__proxy = None
+if not Preferences.getUI("UseProxy"):
-url = QUrl("ftp://{0}:{1}".format(
+proxyType = E5FtpProxyType.NoProxy
-Preferences.getHelp("SyncFtpServer"),
+else:
-Preferences.getHelp("SyncFtpPort")
+proxyType = Preferences.getUI("ProxyType/Ftp")
-))
+if proxyType != E5FtpProxyType.NoProxy:
-query = QNetworkProxyQuery(url)
+self.__ftp.setProxy(proxyType,
-proxyList = E5NetworkProxyFactory().queryProxy(query)
+Preferences.getUI("ProxyHost/Ftp"),
-ftpProxy = QNetworkProxy()
+Preferences.getUI("ProxyPort/Ftp"))
-for proxy in proxyList:
+if proxyType != E5FtpProxyType.NonAuthorizing:
-if proxy.type() == QNetworkProxy.NoProxy or \
+self.__ftp.setProxyAuthentication(
-proxy.type() == QNetworkProxy.FtpCachingProxy:
+Preferences.getUI("ProxyUser/Ftp"),
-ftpProxy = proxy
+Preferences.getUI("ProxyPassword/Ftp"),
-break
+Preferences.getUI("ProxyAccount/Ftp"))
-if ftpProxy.type() == QNetworkProxy.DefaultProxy:
-self.syncError.emit(self.trUtf8("No suitable proxy found."))
-return
-elif ftpProxy.type() == QNetworkProxy.FtpCachingProxy:
-self.__proxy = ftpProxy
 QTimer.singleShot(0, self.__doFtpCommands)
 def __doFtpCommands(self):
 """
 self.__changeToStore()
 self.__ftp.retrlines("LIST", self.__dirListCallback)
 self.__initialSync()
 self.__state = "idle"
 self.__idleTimer.start()
-except ftplib.all_errors as err:
+except (ftplib.all_errors, E5FtpProxyError) as err:
 self.syncError.emit(str(err))
 def __connectAndLogin(self):
 """
 Private method to connect to the FTP server and log in.
 @return flag indicating a successful log in (boolean)
 """
-retry = True
+self.__ftp.connect(
-while retry:
+Preferences.getHelp("SyncFtpServer"),
-if self.__proxy:
+Preferences.getHelp("SyncFtpPort"),
-self.__ftp.connect(
+timeout=5)
-self.__proxy.hostName(),
+self.__ftp.login(
-self.__proxy.port(),
+Preferences.getHelp("SyncFtpUser"),
-timeout=10)
+Preferences.getHelp("SyncFtpPassword"))
-else:
+self.__connected = True
-self.__ftp.connect(
+return True
-Preferences.getHelp("SyncFtpServer"),
-Preferences.getHelp("SyncFtpPort"),
-timeout=10)
-ok, retry = self.__doFtpLogin(
-Preferences.getHelp("SyncFtpUser"),
-Preferences.getHelp("SyncFtpPassword"))
-self.__connected = ok
-if not ok:
-self.syncError.emit(self.trUtf8("Cannot log in to FTP host."))
-return ok
-def __doFtpLogin(self, username, password):
-"""
-Private method to do the FTP login with asking for a username and password,
-if the login fails with an error 530.
-@param username user name to use for the login (string)
-@param password password to use for the login (string)
-@return tuple of two flags indicating a successful login and
-if the login should be retried (boolean, boolean)
-"""
-# 1. do proxy login, if a proxy is used
-if self.__proxy:
-try:
-self.__ftp.login(self.__proxy.user(), self.__proxy.password())
-except ftplib.error_perm as err:
-code, msg = err.args[0].split(None, 1)
-if code.strip() == "530":
-auth = QAuthenticator()
-auth.setOption("realm", self.__proxy.hostName())
-proxyAuthenticationRequired(self.__proxy, auth)
-if not auth.isNull() and auth.user():
-self.__proxy.setUser(auth.user())
-self.__proxy.setPassword(auth.password())
-return False, True
-return False, False
-# 2. do the real login
-if self.__proxy:
-loginName = "{0}@{1}".format(
-username, Preferences.getHelp("SyncFtpServer"))
-if Preferences.getHelp("SyncFtpPort") != ftplib.FTP_PORT:
-loginName = "{0}:{1}".format(
-loginName, Preferences.getHelp("SyncFtpPort"))
-else:
-loginName = username
-self.__ftp.login(loginName, password)
-return True, False
 def __changeToStore(self):
 """
 Private slot to change to the storage directory.
 while storePathList:
 path = storePathList[0]
 try:
 self.__ftp.cwd(path)
 except ftplib.error_perm as err:
-code, msg = err.args[0].split(None, 1)
+code = err.args[0].strip()[:3]
-if code.strip() == "550":
+if code == "550":
 # path does not exist, create it
 self.__ftp.mkd(path)
 self.__ftp.cwd(path)
 else:
 raise
 Private method to upload the given file.
 @param type_ type of the synchronization event (string one
 of "bookmarks", "history", "passwords", "useragents" or "speeddial")
 @param fileName name of the file to be uploaded (string)
-"""
+@return flag indicating success (boolean)
+"""
+res = False
 data = self.readFile(fileName, type_)
 if data.isEmpty():
 self.syncStatus.emit(type_, self._messages[type_]["LocalMissing"])
 self.syncFinished(type_, False, False)
 else:
 self.__ftp.storbinary(
 "STOR {0}".format(self._remoteFiles[type_]),
 buffer,
 callback=lambda x: QCoreApplication.processEvents())
 self.syncFinished.emit(type_, True, False)
+res = True
 except ftplib.all_errors as err:
 self.syncStatus.emit(type_, str(err))
 self.syncFinished.emit(type_, False, False)
+return res
 def __initialSyncFile(self, type_, fileName):
 """
 Private method to do the initial synchronization of the given file.
 return
 # upload the changed file
 self.__state = "uploading"
 self.syncStatus.emit(type_, self._messages[type_]["Uploading"])
-self.__uploadFile(type_, fileName)
+if self.__uploadFile(type_, fileName):
 self.syncStatus.emit(type_, self.trUtf8("Synchronization finished."))
 self.__state = "idle"
 def syncBookmarks(self):
 """
 Public method to synchronize the bookmarks.
 """
 if self.__state == "idle" and self.__connected:
 try:
 self.__ftp.voidcmd("NOOP")
 except ftplib.Error as err:
-code, msg = err.args[0].split(None, 1)
+code = err.args[0].strip()[:3]
-if code.strip() == "421":
+if code == "421":
 self.__connected = False
 except IOError:
 self.__connected = False

Mercurial Repositories > eric / file comparison

comparison: Helpviewer/Sync/FtpSyncHandler.py

Helpviewer/Sync/FtpSyncHandler.py