def __init__(self, url, accessHandler, parent=None):
"""
Constructor
@param url requested FTP URL (QUrl)
@param accessHandler reference to the access handler (FtpAccessHandler)
@param parent reference to the parent object (QObject)
"""
super(FtpReply, self).__init__(parent)
self.__manager = parent
self.__handler = accessHandler
self.__ftp = E5Ftp()
self.__items = []
self.__content = QByteArray()
self.__units = [
"Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"
]
self.__dirLineParser = FtpDirLineParser()
self.__fileBytesReceived = 0
if url.path() == "":
url.setPath("/")
self.setUrl(url)
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(proxyType, Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
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.__dirLineParser = FtpDirLineParser()
self.__remoteFilesFound = {}
self.__idleTimer = QTimer(self)
self.__idleTimer.setInterval(
Preferences.getHelp("SyncFtpIdleTimeout") * 1000)
self.__idleTimer.timeout.connect(self.__idleTimeout)
self.__ftp = E5Ftp()
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(proxyType, Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
def __init__(self, url, accessHandler, parent=None):
"""
Constructor
@param url requested FTP URL (QUrl)
@param accessHandler reference to the access handler (FtpAccessHandler)
@param parent reference to the parent object (QObject)
"""
super(FtpReply, self).__init__(parent)
self.__manager = parent
self.__handler = accessHandler
self.__ftp = E5Ftp()
self.__items = []
self.__content = QByteArray()
self.__units = ["Bytes", "KB", "MB", "GB", "TB",
"PB", "EB", "ZB", "YB"]
self.__dirLineParser = FtpDirLineParser()
self.__fileBytesReceived = 0
if url.path() == "":
url.setPath("/")
self.setUrl(url)
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(
proxyType,
Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
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.__dirLineParser = FtpDirLineParser()
self.__remoteFilesFound = {}
self.__idleTimer = QTimer(self)
self.__idleTimer.setInterval(
Preferences.getHelp("SyncFtpIdleTimeout") * 1000)
self.__idleTimer.timeout.connect(self.__idleTimeout)
self.__ftp = E5Ftp()
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(
proxyType,
Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
class FtpReply(QNetworkReply):
"""
Class implementing a network reply for FTP resources.
"""
def __init__(self, url, accessHandler, parent=None):
"""
Constructor
@param url requested FTP URL (QUrl)
@param accessHandler reference to the access handler (FtpAccessHandler)
@param parent reference to the parent object (QObject)
"""
super(FtpReply, self).__init__(parent)
self.__manager = parent
self.__handler = accessHandler
self.__ftp = E5Ftp()
self.__items = []
self.__content = QByteArray()
self.__units = [
"Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"
]
self.__dirLineParser = FtpDirLineParser()
self.__fileBytesReceived = 0
if url.path() == "":
url.setPath("/")
self.setUrl(url)
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(proxyType, Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
def abort(self):
"""
Public slot to abort the operation.
"""
# do nothing
pass
def bytesAvailable(self):
"""
Public method to determined the bytes available for being read.
@return bytes available (integer)
"""
return self.__content.size()
def isSequential(self):
"""
Public method to check for sequential access.
@return flag indicating sequential access (boolean)
"""
return True
def readData(self, maxlen):
"""
Public method to retrieve data from the reply object.
@param maxlen maximum number of bytes to read (integer)
@return string containing the data (bytes)
"""
if self.__content.size():
len_ = min(maxlen, self.__content.size())
buffer = bytes(self.__content[:len_])
self.__content.remove(0, len_)
return buffer
def __doFtpCommands(self):
"""
Private slot doing the sequence of FTP commands to get the requested
result.
"""
retry = True
try:
username = self.url().userName()
password = self.url().password()
byAuth = False
while retry:
try:
self.__ftp.connect(self.url().host(),
self.url().port(ftplib.FTP_PORT),
timeout=10)
except E5FtpProxyError as err:
self.setError(QNetworkReply.ProxyNotFoundError, str(err))
self.error.emit(QNetworkReply.ProxyNotFoundError)
self.finished.emit()
ok, retry = self.__doFtpLogin(username, password, byAuth)
if not ok and retry:
auth = self.__handler.getAuthenticator(self.url().host())
if auth and not auth.isNull() and auth.user():
username = auth.user()
password = auth.password()
byAuth = True
else:
retry = False
if ok:
self.__ftp.retrlines("LIST " + self.url().path(),
self.__dirCallback)
if len(self.__items) == 1 and \
self.__items[0].isFile():
self.__fileBytesReceived = 0
self.__setContent()
self.__ftp.retrbinary("RETR " + self.url().path(),
self.__retrCallback)
self.__content.append(512 * b' ')
self.readyRead.emit()
else:
self.__setListContent()
self.__ftp.quit()
except ftplib.all_errors as err:
if isinstance(err, socket.gaierror):
errCode = QNetworkReply.HostNotFoundError
elif isinstance(err, socket.error) and \
err.errno == errno.ECONNREFUSED:
errCode = QNetworkReply.ConnectionRefusedError
else:
errCode = QNetworkReply.ProtocolFailure
self.setError(errCode, str(err))
self.error.emit(errCode)
self.finished.emit()
def __doFtpLogin(self, username, password, byAuth=False):
"""
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)
@param byAuth flag indicating that the login data was provided by an
authenticator (boolean)
@return tuple of two flags indicating a successful login and
if the login should be retried (boolean, boolean)
"""
try:
self.__ftp.login(username, password)
return True, False
except E5FtpProxyError as err:
code = str(err)[:3]
if code[1] == "5":
# could be a 530, check second line
lines = str(err).splitlines()
if lines[1][:3] == "530":
if "usage" in "\n".join(lines[1:].lower()):
# found a not supported proxy
self.setError(
QNetworkReply.ProxyConnectionRefusedError,
self.tr("The proxy type seems to be wrong."
" If it is not in the list of"
" supported proxy types please report"
" it with the instructions given by"
" the proxy.\n{0}").format("\n".join(
lines[1:])))
self.error.emit(
QNetworkReply.ProxyConnectionRefusedError)
return False, False
else:
from UI.AuthenticationDialog import \
AuthenticationDialog
info = self.tr(
"<b>Connect to proxy '{0}' using:</b>")\
.format(Utilities.html_encode(
Preferences.getUI("ProxyHost/Ftp")))
dlg = AuthenticationDialog(
info, Preferences.getUI("ProxyUser/Ftp"), True)
dlg.setData(Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"))
if dlg.exec_() == QDialog.Accepted:
username, password = dlg.getData()
if dlg.shallSave():
Preferences.setUI("ProxyUser/Ftp", username)
Preferences.setUI("ProxyPassword/Ftp",
password)
self.__ftp.setProxyAuthentication(
username, password)
return False, True
return False, False
except (ftplib.error_perm, ftplib.error_temp) as err:
code = err.args[0].strip()[:3]
if code in ["530", "421"]:
# error 530 -> Login incorrect
# error 421 -> Login may be incorrect (reported by some
# proxies)
if byAuth:
self.__handler.setAuthenticator(self.url().host(), None)
auth = None
else:
auth = self.__handler.getAuthenticator(self.url().host())
if not auth or auth.isNull() or not auth.user():
auth = QAuthenticator()
self.__manager.authenticationRequired.emit(self, auth)
if not auth.isNull():
if auth.user():
self.__handler.setAuthenticator(
self.url().host(), auth)
return False, True
return False, False
return False, True
else:
raise
def __dirCallback(self, line):
"""
Private slot handling the receipt of directory listings.
@param line the received line of the directory listing (string)
"""
try:
urlInfo = self.__dirLineParser.parseLine(line)
except FtpDirLineParserError:
# silently ignore parser errors
urlInfo = None
if urlInfo:
self.__items.append(urlInfo)
QCoreApplication.processEvents()
def __retrCallback(self, data):
"""
Private slot handling the reception of data.
@param data data received from the FTP server (bytes)
"""
self.__content += QByteArray(data)
self.__fileBytesReceived += len(data)
self.downloadProgress.emit(self.__fileBytesReceived,
self.__items[0].size())
self.readyRead.emit()
QCoreApplication.processEvents()
def __setContent(self):
"""
Private method to finish the setup of the data.
"""
mtype, encoding = mimetypes.guess_type(self.url().toString())
self.open(QIODevice.ReadOnly | QIODevice.Unbuffered)
self.setHeader(QNetworkRequest.ContentLengthHeader,
self.__items[0].size())
if mtype:
self.setHeader(QNetworkRequest.ContentTypeHeader, mtype)
self.setAttribute(QNetworkRequest.HttpStatusCodeAttribute, 200)
self.setAttribute(QNetworkRequest.HttpReasonPhraseAttribute, "Ok")
self.metaDataChanged.emit()
def __cssLinkClass(self, icon, size=32):
"""
Private method to generate a link class with an icon.
@param icon icon to be included (QIcon)
@param size size of the icon to be generated (integer)
@return CSS class string (string)
"""
cssString = \
"""a.{{0}} {{{{\n"""\
""" padding-left: {0}px;\n"""\
""" background: transparent url(data:image/png;base64,{1})"""\
""" no-repeat center left;\n"""\
""" font-weight: bold;\n"""\
"""}}}}\n"""
pixmap = icon.pixmap(size, size)
imageBuffer = QBuffer()
imageBuffer.open(QIODevice.ReadWrite)
if not pixmap.save(imageBuffer, "PNG"):
# write a blank pixmap on error
pixmap = QPixmap(size, size)
pixmap.fill(Qt.transparent)
imageBuffer.buffer().clear()
pixmap.save(imageBuffer, "PNG")
return cssString.format(
size + 4, str(imageBuffer.buffer().toBase64(), encoding="ascii"))
def __setListContent(self):
"""
Private method to prepare the content for the reader.
"""
u = self.url()
if not u.path().endswith("/"):
u.setPath(u.path() + "/")
baseUrl = self.url().toString()
basePath = u.path()
linkClasses = {}
iconSize = QWebSettings.globalSettings().fontSize(
QWebSettings.DefaultFontSize)
parent = u.resolved(QUrl(".."))
if parent.isParentOf(u):
icon = UI.PixmapCache.getIcon("up.png")
linkClasses["link_parent"] = \
self.__cssLinkClass(icon, iconSize).format("link_parent")
parentStr = self.tr(
""" <p><a class="link_parent" href="{0}">"""
"""Change to parent directory</a></p>""").format(
parent.toString())
else:
parentStr = ""
row = \
""" <tr class="{0}">"""\
"""<td class="name"><a class="{1}" href="{2}">{3}</a></td>"""\
"""<td class="size">{4}</td>"""\
"""<td class="modified">{5}</td>"""\
"""</tr>\n"""
table = self.tr(""" <tr>"""
"""<th align="left">Name</th>"""
"""<th>Size</th>"""
"""<th align="left">Last modified</th>"""
"""</tr>\n""")
i = 0
for item in self.__items:
name = item.name()
if item.isDir() and not name.endswith("/"):
name += "/"
child = u.resolved(QUrl(name.replace(":", "%3A")))
if item.isFile():
size = item.size()
unit = 0
while size:
newSize = size // 1024
if newSize and unit < len(self.__units):
size = newSize
unit += 1
else:
break
sizeStr = self.tr("{0} {1}", "size unit")\
.format(size, self.__units[unit])
linkClass = "link_file"
if linkClass not in linkClasses:
icon = UI.PixmapCache.getIcon("fileMisc.png")
linkClasses[linkClass] = \
self.__cssLinkClass(icon, iconSize).format(linkClass)
else:
sizeStr = ""
linkClass = "link_dir"
if linkClass not in linkClasses:
icon = UI.PixmapCache.getIcon("dirClosed.png")
linkClasses[linkClass] = \
self.__cssLinkClass(icon, iconSize).format(linkClass)
table += row.format(
i == 0 and "odd" or "even",
linkClass,
child.toString(),
Utilities.html_encode(item.name()),
sizeStr,
item.lastModified().toString("yyyy-MM-dd hh:mm"),
)
i = 1 - i
content = ftpListPage_html.format(
Utilities.html_encode(baseUrl), "".join(linkClasses.values()),
self.tr("Listing of {0}").format(basePath), parentStr, table)
self.__content = QByteArray(content.encode("utf8"))
self.__content.append(512 * b' ')
self.open(QIODevice.ReadOnly | QIODevice.Unbuffered)
self.setHeader(QNetworkRequest.ContentTypeHeader,
"text/html; charset=UTF-8")
self.setHeader(QNetworkRequest.ContentLengthHeader,
self.__content.size())
self.setAttribute(QNetworkRequest.HttpStatusCodeAttribute, 200)
self.setAttribute(QNetworkRequest.HttpReasonPhraseAttribute, "Ok")
self.metaDataChanged.emit()
self.downloadProgress.emit(self.__content.size(),
self.__content.size())
self.readyRead.emit()
class FtpSyncHandler(SyncHandler):
"""
Class implementing a synchronization handler using FTP.
@signal syncStatus(type_, message) emitted to indicate the synchronization
status (string one of "bookmarks", "history", "passwords",
"useragents" or "speeddial", 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", "useragents" or "speeddial", boolean, boolean)
"""
syncStatus = pyqtSignal(str, 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(FtpSyncHandler, self).__init__(parent)
self.__state = "idle"
self.__forceUpload = False
self.__connected = False
self.__remoteFilesFound = {}
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.__dirLineParser = FtpDirLineParser()
self.__remoteFilesFound = {}
self.__idleTimer = QTimer(self)
self.__idleTimer.setInterval(
Preferences.getHelp("SyncFtpIdleTimeout") * 1000)
self.__idleTimer.timeout.connect(self.__idleTimeout)
self.__ftp = E5Ftp()
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(proxyType, Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
def __doFtpCommands(self):
"""
Private slot executing the sequence of FTP commands.
"""
try:
ok = self.__connectAndLogin()
if ok:
self.__changeToStore()
self.__ftp.retrlines("LIST", self.__dirListCallback)
self.__initialSync()
self.__state = "idle"
self.__idleTimer.start()
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)
"""
self.__ftp.connect(Preferences.getHelp("SyncFtpServer"),
Preferences.getHelp("SyncFtpPort"),
timeout=5)
self.__ftp.login(Preferences.getHelp("SyncFtpUser"),
Preferences.getHelp("SyncFtpPassword"))
self.__connected = True
return True
def __changeToStore(self):
"""
Private slot to change to the storage directory.
This action will create the storage path on the server, if it
does not exist. Upon return, the current directory of the server
is the sync directory.
"""
storePathList = \
Preferences.getHelp("SyncFtpPath").replace("\\", "/").split("/")
if storePathList[0] == "":
storePathList.pop(0)
while storePathList:
path = storePathList[0]
try:
self.__ftp.cwd(path)
except ftplib.error_perm as err:
code = err.args[0].strip()[:3]
if code == "550":
# path does not exist, create it
self.__ftp.mkd(path)
self.__ftp.cwd(path)
else:
raise
storePathList.pop(0)
def __dirListCallback(self, line):
"""
Private slot handling the receipt of directory listing lines.
@param line the received line of the directory listing (string)
"""
try:
urlInfo = self.__dirLineParser.parseLine(line)
except FtpDirLineParserError:
# silently ignore parser errors
urlInfo = None
if urlInfo and urlInfo.isValid() and urlInfo.isFile():
if urlInfo.name() in self._remoteFiles.values():
self.__remoteFilesFound[urlInfo.name()] = \
urlInfo.lastModified()
QCoreApplication.processEvents()
def __downloadFile(self, type_, fileName, timestamp):
"""
Private method to downlaod 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 downloaded (string)
@param timestamp time stamp in seconds of the file to be downloaded
(integer)
"""
self.syncStatus.emit(type_, self._messages[type_]["RemoteExists"])
buffer = io.BytesIO()
try:
self.__ftp.retrbinary(
"RETR {0}".format(self._remoteFiles[type_]),
lambda x: self.__downloadFileCallback(buffer, x))
ok, error = self.writeFile(QByteArray(buffer.getvalue()), fileName,
type_, timestamp)
if not ok:
self.syncStatus.emit(type_, error)
self.syncFinished.emit(type_, ok, True)
except ftplib.all_errors as err:
self.syncStatus.emit(type_, str(err))
self.syncFinished.emit(type_, False, True)
def __downloadFileCallback(self, buffer, data):
"""
Private method receiving the downloaded data.
@param buffer reference to the buffer (io.BytesIO)
@param data byte string to store in the buffer (bytes)
@return number of bytes written to the buffer (integer)
"""
res = buffer.write(data)
QCoreApplication.processEvents()
return res
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", "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.emit(type_, False, False)
else:
buffer = io.BytesIO(data.data())
try:
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.
@param type_ type of the synchronization event (string one
of "bookmarks", "history", "passwords", "useragents" or
"speeddial")
@param fileName name of the file to be synchronized (string)
"""
if not self.__forceUpload and \
self._remoteFiles[type_] in self.__remoteFilesFound:
if QFileInfo(fileName).lastModified() < \
self.__remoteFilesFound[self._remoteFiles[type_]]:
self.__downloadFile(
type_, fileName, self.__remoteFilesFound[
self._remoteFiles[type_]].toTime_t())
else:
self.syncStatus.emit(type_,
self.tr("No synchronization required."))
self.syncFinished.emit(type_, True, True)
else:
if self._remoteFiles[type_] not in self.__remoteFilesFound:
self.syncStatus.emit(type_,
self._messages[type_]["RemoteMissing"])
else:
self.syncStatus.emit(type_,
self._messages[type_]["LocalNewer"])
self.__uploadFile(type_, fileName)
def __initialSync(self):
"""
Private slot to do the initial synchronization.
"""
# Bookmarks
if Preferences.getHelp("SyncBookmarks"):
self.__initialSyncFile(
"bookmarks",
Helpviewer.HelpWindow.HelpWindow.bookmarksManager().
getFileName())
# History
if Preferences.getHelp("SyncHistory"):
self.__initialSyncFile(
"history",
Helpviewer.HelpWindow.HelpWindow.historyManager().getFileName(
))
# Passwords
if Preferences.getHelp("SyncPasswords"):
self.__initialSyncFile(
"passwords",
Helpviewer.HelpWindow.HelpWindow.passwordManager().getFileName(
))
# User Agent Settings
if Preferences.getHelp("SyncUserAgents"):
self.__initialSyncFile(
"useragents",
Helpviewer.HelpWindow.HelpWindow.userAgentsManager().
getFileName())
# Speed Dial Settings
if Preferences.getHelp("SyncSpeedDial"):
self.__initialSyncFile(
"speeddial",
Helpviewer.HelpWindow.HelpWindow.speedDial().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", "useragents" or
"speeddial")
@param fileName name of the file to be synchronized (string)
"""
if self.__state == "initializing":
return
# use idle timeout to check, if we are still connected
if self.__connected:
self.__idleTimeout()
if not self.__connected or self.__ftp.sock is None:
ok = self.__connectAndLogin()
if not ok:
self.syncStatus.emit(type_,
self.tr("Cannot log in to FTP host."))
return
# upload the changed file
self.__state = "uploading"
self.syncStatus.emit(type_, self._messages[type_]["Uploading"])
if self.__uploadFile(type_, fileName):
self.syncStatus.emit(type_, self.tr("Synchronization finished."))
self.__state = "idle"
def syncBookmarks(self):
"""
Public method to synchronize the bookmarks.
"""
self.__syncFile(
"bookmarks",
Helpviewer.HelpWindow.HelpWindow.bookmarksManager().getFileName())
def syncHistory(self):
"""
Public method to synchronize the history.
"""
self.__syncFile(
"history",
Helpviewer.HelpWindow.HelpWindow.historyManager().getFileName())
def syncPasswords(self):
"""
Public method to synchronize the passwords.
"""
self.__syncFile(
"passwords",
Helpviewer.HelpWindow.HelpWindow.passwordManager().getFileName())
def syncUserAgents(self):
"""
Public method to synchronize the user agents.
"""
self.__syncFile(
"useragents",
Helpviewer.HelpWindow.HelpWindow.userAgentsManager().getFileName())
def syncSpeedDial(self):
"""
Public method to synchronize the speed dial data.
"""
self.__syncFile(
"speeddial",
Helpviewer.HelpWindow.HelpWindow.speedDial().getFileName())
def shutdown(self):
"""
Public method to shut down the handler.
"""
if self.__idleTimer.isActive():
self.__idleTimer.stop()
try:
if self.__connected:
self.__ftp.quit()
except ftplib.all_errors:
pass # ignore FTP errors because we are shutting down anyway
self.__connected = False
def __idleTimeout(self):
"""
Private slot to prevent a disconnect from the server.
"""
if self.__state == "idle" and self.__connected:
try:
self.__ftp.voidcmd("NOOP")
except ftplib.Error as err:
code = err.args[0].strip()[:3]
if code == "421":
self.__connected = False
except IOError:
self.__connected = False
class FtpReply(QNetworkReply):
"""
Class implementing a network reply for FTP resources.
"""
def __init__(self, url, accessHandler, parent=None):
"""
Constructor
@param url requested FTP URL (QUrl)
@param accessHandler reference to the access handler (FtpAccessHandler)
@param parent reference to the parent object (QObject)
"""
super(FtpReply, self).__init__(parent)
self.__manager = parent
self.__handler = accessHandler
self.__ftp = E5Ftp()
self.__items = []
self.__content = QByteArray()
self.__units = ["Bytes", "KB", "MB", "GB", "TB",
"PB", "EB", "ZB", "YB"]
self.__dirLineParser = FtpDirLineParser()
self.__fileBytesReceived = 0
if url.path() == "":
url.setPath("/")
self.setUrl(url)
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(
proxyType,
Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
def abort(self):
"""
Public slot to abort the operation.
"""
# do nothing
pass
def bytesAvailable(self):
"""
Public method to determined the bytes available for being read.
@return bytes available (integer)
"""
return self.__content.size()
def isSequential(self):
"""
Public method to check for sequential access.
@return flag indicating sequential access (boolean)
"""
return True
def readData(self, maxlen):
"""
Public method to retrieve data from the reply object.
@param maxlen maximum number of bytes to read (integer)
@return string containing the data (bytes)
"""
if self.__content.size():
len_ = min(maxlen, self.__content.size())
buffer = bytes(self.__content[:len_])
self.__content.remove(0, len_)
return buffer
def __doFtpCommands(self):
"""
Private slot doing the sequence of FTP commands to get the requested
result.
"""
retry = True
try:
username = self.url().userName()
password = self.url().password()
byAuth = False
while retry:
try:
self.__ftp.connect(self.url().host(),
self.url().port(ftplib.FTP_PORT),
timeout=10)
except E5FtpProxyError as err:
self.setError(QNetworkReply.ProxyNotFoundError, str(err))
self.error.emit(QNetworkReply.ProxyNotFoundError)
self.finished.emit()
ok, retry = self.__doFtpLogin(username, password, byAuth)
if not ok and retry:
auth = self.__handler.getAuthenticator(self.url().host())
if auth and not auth.isNull() and auth.user():
username = auth.user()
password = auth.password()
byAuth = True
else:
retry = False
if ok:
self.__ftp.retrlines("LIST " + self.url().path(),
self.__dirCallback)
if len(self.__items) == 1 and \
self.__items[0].isFile():
self.__fileBytesReceived = 0
self.__setContent()
self.__ftp.retrbinary(
"RETR " + self.url().path(), self.__retrCallback)
self.__content.append(512 * b' ')
self.readyRead.emit()
else:
self.__setListContent()
self.__ftp.quit()
except ftplib.all_errors as err:
if isinstance(err, socket.gaierror):
errCode = QNetworkReply.HostNotFoundError
elif isinstance(err, socket.error) and \
err.errno == errno.ECONNREFUSED:
errCode = QNetworkReply.ConnectionRefusedError
else:
errCode = QNetworkReply.ProtocolFailure
self.setError(errCode, str(err))
self.error.emit(errCode)
self.finished.emit()
def __doFtpLogin(self, username, password, byAuth=False):
"""
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)
@param byAuth flag indicating that the login data was provided by an
authenticator (boolean)
@return tuple of two flags indicating a successful login and
if the login should be retried (boolean, boolean)
"""
try:
self.__ftp.login(username, password)
return True, False
except E5FtpProxyError as err:
code = str(err)[:3]
if code[1] == "5":
# could be a 530, check second line
lines = str(err).splitlines()
if lines[1][:3] == "530":
if "usage" in "\n".join(lines[1:].lower()):
# found a not supported proxy
self.setError(
QNetworkReply.ProxyConnectionRefusedError,
self.tr("The proxy type seems to be wrong."
" If it is not in the list of"
" supported proxy types please report"
" it with the instructions given by"
" the proxy.\n{0}").format(
"\n".join(lines[1:])))
self.error.emit(
QNetworkReply.ProxyConnectionRefusedError)
return False, False
else:
from UI.AuthenticationDialog import \
AuthenticationDialog
info = self.tr(
"<b>Connect to proxy '{0}' using:</b>")\
.format(Utilities.html_encode(
Preferences.getUI("ProxyHost/Ftp")))
dlg = AuthenticationDialog(
info, Preferences.getUI("ProxyUser/Ftp"), True)
dlg.setData(Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"))
if dlg.exec_() == QDialog.Accepted:
username, password = dlg.getData()
if dlg.shallSave():
Preferences.setUI("ProxyUser/Ftp", username)
Preferences.setUI(
"ProxyPassword/Ftp", password)
self.__ftp.setProxyAuthentication(username,
password)
return False, True
return False, False
except (ftplib.error_perm, ftplib.error_temp) as err:
code = err.args[0].strip()[:3]
if code in ["530", "421"]:
# error 530 -> Login incorrect
# error 421 -> Login may be incorrect (reported by some
# proxies)
if byAuth:
self.__handler.setAuthenticator(self.url().host(), None)
auth = None
else:
auth = self.__handler.getAuthenticator(self.url().host())
if not auth or auth.isNull() or not auth.user():
auth = QAuthenticator()
self.__manager.authenticationRequired.emit(self, auth)
if not auth.isNull():
if auth.user():
self.__handler.setAuthenticator(self.url().host(),
auth)
return False, True
return False, False
return False, True
else:
raise
def __dirCallback(self, line):
"""
Private slot handling the receipt of directory listings.
@param line the received line of the directory listing (string)
"""
try:
urlInfo = self.__dirLineParser.parseLine(line)
except FtpDirLineParserError:
# silently ignore parser errors
urlInfo = None
if urlInfo:
self.__items.append(urlInfo)
QCoreApplication.processEvents()
def __retrCallback(self, data):
"""
Private slot handling the reception of data.
@param data data received from the FTP server (bytes)
"""
self.__content += QByteArray(data)
self.__fileBytesReceived += len(data)
self.downloadProgress.emit(
self.__fileBytesReceived, self.__items[0].size())
self.readyRead.emit()
QCoreApplication.processEvents()
def __setContent(self):
"""
Private method to finish the setup of the data.
"""
mtype, encoding = mimetypes.guess_type(self.url().toString())
self.open(QIODevice.ReadOnly | QIODevice.Unbuffered)
self.setHeader(QNetworkRequest.ContentLengthHeader,
self.__items[0].size())
if mtype:
self.setHeader(QNetworkRequest.ContentTypeHeader, mtype)
self.setAttribute(QNetworkRequest.HttpStatusCodeAttribute, 200)
self.setAttribute(QNetworkRequest.HttpReasonPhraseAttribute, "Ok")
self.metaDataChanged.emit()
def __cssLinkClass(self, icon, size=32):
"""
Private method to generate a link class with an icon.
@param icon icon to be included (QIcon)
@param size size of the icon to be generated (integer)
@return CSS class string (string)
"""
cssString = \
"""a.{{0}} {{{{\n"""\
""" padding-left: {0}px;\n"""\
""" background: transparent url(data:image/png;base64,{1})"""\
""" no-repeat center left;\n"""\
""" font-weight: bold;\n"""\
"""}}}}\n"""
pixmap = icon.pixmap(size, size)
imageBuffer = QBuffer()
imageBuffer.open(QIODevice.ReadWrite)
if not pixmap.save(imageBuffer, "PNG"):
# write a blank pixmap on error
pixmap = QPixmap(size, size)
pixmap.fill(Qt.transparent)
imageBuffer.buffer().clear()
pixmap.save(imageBuffer, "PNG")
return cssString.format(
size + 4,
str(imageBuffer.buffer().toBase64(), encoding="ascii"))
def __setListContent(self):
"""
Private method to prepare the content for the reader.
"""
u = self.url()
if not u.path().endswith("/"):
u.setPath(u.path() + "/")
baseUrl = self.url().toString()
basePath = u.path()
linkClasses = {}
iconSize = QWebSettings.globalSettings().fontSize(
QWebSettings.DefaultFontSize)
parent = u.resolved(QUrl(".."))
if parent.isParentOf(u):
icon = UI.PixmapCache.getIcon("up.png")
linkClasses["link_parent"] = \
self.__cssLinkClass(icon, iconSize).format("link_parent")
parentStr = self.tr(
""" <p><a class="link_parent" href="{0}">"""
"""Change to parent directory</a></p>"""
).format(parent.toString())
else:
parentStr = ""
row = \
""" <tr class="{0}">"""\
"""<td class="name"><a class="{1}" href="{2}">{3}</a></td>"""\
"""<td class="size">{4}</td>"""\
"""<td class="modified">{5}</td>"""\
"""</tr>\n"""
table = self.tr(
""" <tr>"""
"""<th align="left">Name</th>"""
"""<th>Size</th>"""
"""<th align="left">Last modified</th>"""
"""</tr>\n"""
)
i = 0
for item in self.__items:
name = item.name()
if item.isDir() and not name.endswith("/"):
name += "/"
child = u.resolved(QUrl(name.replace(":", "%3A")))
if item.isFile():
size = item.size()
unit = 0
while size:
newSize = size // 1024
if newSize and unit < len(self.__units):
size = newSize
unit += 1
else:
break
sizeStr = self.tr("{0} {1}", "size unit")\
.format(size, self.__units[unit])
linkClass = "link_file"
if linkClass not in linkClasses:
icon = UI.PixmapCache.getIcon("fileMisc.png")
linkClasses[linkClass] = \
self.__cssLinkClass(icon, iconSize).format(linkClass)
else:
sizeStr = ""
linkClass = "link_dir"
if linkClass not in linkClasses:
icon = UI.PixmapCache.getIcon("dirClosed.png")
linkClasses[linkClass] = \
self.__cssLinkClass(icon, iconSize).format(linkClass)
table += row.format(
i == 0 and "odd" or "even",
linkClass,
child.toString(),
Utilities.html_encode(item.name()),
sizeStr,
item.lastModified().toString("yyyy-MM-dd hh:mm"),
)
i = 1 - i
content = ftpListPage_html.format(
Utilities.html_encode(baseUrl),
"".join(linkClasses.values()),
self.tr("Listing of {0}").format(basePath),
parentStr,
table
)
self.__content = QByteArray(content.encode("utf8"))
self.__content.append(512 * b' ')
self.open(QIODevice.ReadOnly | QIODevice.Unbuffered)
self.setHeader(
QNetworkRequest.ContentTypeHeader, "text/html; charset=UTF-8")
self.setHeader(
QNetworkRequest.ContentLengthHeader, self.__content.size())
self.setAttribute(QNetworkRequest.HttpStatusCodeAttribute, 200)
self.setAttribute(QNetworkRequest.HttpReasonPhraseAttribute, "Ok")
self.metaDataChanged.emit()
self.downloadProgress.emit(
self.__content.size(), self.__content.size())
self.readyRead.emit()
class FtpSyncHandler(SyncHandler):
"""
Class implementing a synchronization handler using FTP.
@signal syncStatus(type_, message) emitted to indicate the synchronization
status (string one of "bookmarks", "history", "passwords",
"useragents" or "speeddial", 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", "useragents" or "speeddial", boolean, boolean)
"""
syncStatus = pyqtSignal(str, 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(FtpSyncHandler, self).__init__(parent)
self.__state = "idle"
self.__forceUpload = False
self.__connected = False
self.__remoteFilesFound = {}
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.__dirLineParser = FtpDirLineParser()
self.__remoteFilesFound = {}
self.__idleTimer = QTimer(self)
self.__idleTimer.setInterval(
Preferences.getHelp("SyncFtpIdleTimeout") * 1000)
self.__idleTimer.timeout.connect(self.__idleTimeout)
self.__ftp = E5Ftp()
# do proxy setup
if not Preferences.getUI("UseProxy"):
proxyType = E5FtpProxyType.NoProxy
else:
proxyType = Preferences.getUI("ProxyType/Ftp")
if proxyType != E5FtpProxyType.NoProxy:
self.__ftp.setProxy(
proxyType,
Preferences.getUI("ProxyHost/Ftp"),
Preferences.getUI("ProxyPort/Ftp"))
if proxyType != E5FtpProxyType.NonAuthorizing:
self.__ftp.setProxyAuthentication(
Preferences.getUI("ProxyUser/Ftp"),
Preferences.getUI("ProxyPassword/Ftp"),
Preferences.getUI("ProxyAccount/Ftp"))
QTimer.singleShot(0, self.__doFtpCommands)
def __doFtpCommands(self):
"""
Private slot executing the sequence of FTP commands.
"""
try:
ok = self.__connectAndLogin()
if ok:
self.__changeToStore()
self.__ftp.retrlines("LIST", self.__dirListCallback)
self.__initialSync()
self.__state = "idle"
self.__idleTimer.start()
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)
"""
self.__ftp.connect(
Preferences.getHelp("SyncFtpServer"),
Preferences.getHelp("SyncFtpPort"),
timeout=5)
self.__ftp.login(
Preferences.getHelp("SyncFtpUser"),
Preferences.getHelp("SyncFtpPassword"))
self.__connected = True
return True
def __changeToStore(self):
"""
Private slot to change to the storage directory.
This action will create the storage path on the server, if it
does not exist. Upon return, the current directory of the server
is the sync directory.
"""
storePathList = \
Preferences.getHelp("SyncFtpPath").replace("\\", "/").split("/")
if storePathList[0] == "":
storePathList.pop(0)
while storePathList:
path = storePathList[0]
try:
self.__ftp.cwd(path)
except ftplib.error_perm as err:
code = err.args[0].strip()[:3]
if code == "550":
# path does not exist, create it
self.__ftp.mkd(path)
self.__ftp.cwd(path)
else:
raise
storePathList.pop(0)
def __dirListCallback(self, line):
"""
Private slot handling the receipt of directory listing lines.
@param line the received line of the directory listing (string)
"""
try:
urlInfo = self.__dirLineParser.parseLine(line)
except FtpDirLineParserError:
# silently ignore parser errors
urlInfo = None
if urlInfo and urlInfo.isValid() and urlInfo.isFile():
if urlInfo.name() in self._remoteFiles.values():
self.__remoteFilesFound[urlInfo.name()] = \
urlInfo.lastModified()
QCoreApplication.processEvents()
def __downloadFile(self, type_, fileName, timestamp):
"""
Private method to downlaod 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 downloaded (string)
@param timestamp time stamp in seconds of the file to be downloaded
(integer)
"""
self.syncStatus.emit(type_, self._messages[type_]["RemoteExists"])
buffer = io.BytesIO()
try:
self.__ftp.retrbinary(
"RETR {0}".format(self._remoteFiles[type_]),
lambda x: self.__downloadFileCallback(buffer, x))
ok, error = self.writeFile(
QByteArray(buffer.getvalue()), fileName, type_, timestamp)
if not ok:
self.syncStatus.emit(type_, error)
self.syncFinished.emit(type_, ok, True)
except ftplib.all_errors as err:
self.syncStatus.emit(type_, str(err))
self.syncFinished.emit(type_, False, True)
def __downloadFileCallback(self, buffer, data):
"""
Private method receiving the downloaded data.
@param buffer reference to the buffer (io.BytesIO)
@param data byte string to store in the buffer (bytes)
@return number of bytes written to the buffer (integer)
"""
res = buffer.write(data)
QCoreApplication.processEvents()
return res
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", "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.emit(type_, False, False)
else:
buffer = io.BytesIO(data.data())
try:
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.
@param type_ type of the synchronization event (string one
of "bookmarks", "history", "passwords", "useragents" or
"speeddial")
@param fileName name of the file to be synchronized (string)
"""
if not self.__forceUpload and \
self._remoteFiles[type_] in self.__remoteFilesFound:
if QFileInfo(fileName).lastModified() < \
self.__remoteFilesFound[self._remoteFiles[type_]]:
self.__downloadFile(
type_, fileName,
self.__remoteFilesFound[self._remoteFiles[type_]]
.toTime_t())
else:
self.syncStatus.emit(
type_, self.tr("No synchronization required."))
self.syncFinished.emit(type_, True, True)
else:
if self._remoteFiles[type_] not in self.__remoteFilesFound:
self.syncStatus.emit(
type_, self._messages[type_]["RemoteMissing"])
else:
self.syncStatus.emit(
type_, self._messages[type_]["LocalNewer"])
self.__uploadFile(type_, fileName)
def __initialSync(self):
"""
Private slot to do the initial synchronization.
"""
# Bookmarks
if Preferences.getHelp("SyncBookmarks"):
self.__initialSyncFile(
"bookmarks",
Helpviewer.HelpWindow.HelpWindow.bookmarksManager()
.getFileName())
# History
if Preferences.getHelp("SyncHistory"):
self.__initialSyncFile(
"history",
Helpviewer.HelpWindow.HelpWindow.historyManager()
.getFileName())
# Passwords
if Preferences.getHelp("SyncPasswords"):
self.__initialSyncFile(
"passwords",
Helpviewer.HelpWindow.HelpWindow.passwordManager()
.getFileName())
# User Agent Settings
if Preferences.getHelp("SyncUserAgents"):
self.__initialSyncFile(
"useragents",
Helpviewer.HelpWindow.HelpWindow.userAgentsManager()
.getFileName())
# Speed Dial Settings
if Preferences.getHelp("SyncSpeedDial"):
self.__initialSyncFile(
"speeddial",
Helpviewer.HelpWindow.HelpWindow.speedDial().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", "useragents" or
"speeddial")
@param fileName name of the file to be synchronized (string)
"""
if self.__state == "initializing":
return
# use idle timeout to check, if we are still connected
if self.__connected:
self.__idleTimeout()
if not self.__connected or self.__ftp.sock is None:
ok = self.__connectAndLogin()
if not ok:
self.syncStatus.emit(
type_, self.tr("Cannot log in to FTP host."))
return
# upload the changed file
self.__state = "uploading"
self.syncStatus.emit(type_, self._messages[type_]["Uploading"])
if self.__uploadFile(type_, fileName):
self.syncStatus.emit(
type_, self.tr("Synchronization finished."))
self.__state = "idle"
def syncBookmarks(self):
"""
Public method to synchronize the bookmarks.
"""
self.__syncFile(
"bookmarks",
Helpviewer.HelpWindow.HelpWindow.bookmarksManager().getFileName())
def syncHistory(self):
"""
Public method to synchronize the history.
"""
self.__syncFile(
"history",
Helpviewer.HelpWindow.HelpWindow.historyManager().getFileName())
def syncPasswords(self):
"""
Public method to synchronize the passwords.
"""
self.__syncFile(
"passwords",
Helpviewer.HelpWindow.HelpWindow.passwordManager().getFileName())
def syncUserAgents(self):
"""
Public method to synchronize the user agents.
"""
self.__syncFile(
"useragents",
Helpviewer.HelpWindow.HelpWindow.userAgentsManager().getFileName())
def syncSpeedDial(self):
"""
Public method to synchronize the speed dial data.
"""
self.__syncFile(
"speeddial",
Helpviewer.HelpWindow.HelpWindow.speedDial().getFileName())
def shutdown(self):
"""
Public method to shut down the handler.
"""
if self.__idleTimer.isActive():
self.__idleTimer.stop()
try:
if self.__connected:
self.__ftp.quit()
except ftplib.all_errors:
pass # ignore FTP errors because we are shutting down anyway
self.__connected = False
def __idleTimeout(self):
"""
Private slot to prevent a disconnect from the server.
"""
if self.__state == "idle" and self.__connected:
try:
self.__ftp.voidcmd("NOOP")
except ftplib.Error as err:
code = err.args[0].strip()[:3]
if code == "421":
self.__connected = False
except IOError:
self.__connected = False
