def _installGPG(self, phase=0, dt=None):
if getPlatform() == PLATFORM_MAC:
# TODO handle errors
if phase == 0:
self._ui.setInteractive(False)
self._setStatus("Searching for latest version...")
dt = DownloadThread(getValidQtParent(), self.logger, "https://gpgtools.org/releases/macgpg2/appcast.xml")
dt.success.connect(partial(self._install_gpg_finished, 0))
dt.error.connect(partial(self._install_gpg_failed, 0))
dt.start()
elif phase == 1:
xmlContent = dt.getResult()
dt.close()
e = ElementTree.fromstring(xmlContent)
dmgURL = e.iter("channel").next().iter("item").next().iter("enclosure").next().attrib["url"]
tmpFile = tempfile.NamedTemporaryFile(suffix=".dmg", prefix="macgpg", delete=False)
self.logger.debug("Downloading %s to %s", dmgURL, tmpFile.name)
self._setStatus("Downloading MacGPG...", progress=True)
self._ui.setProgress(0)
dt = DownloadThread(getValidQtParent(), self.logger, dmgURL, target=tmpFile, progress=True)
dt.success.connect(partial(self._install_gpg_finished, 1))
dt.error.connect(partial(self._install_gpg_failed, 1))
dt.progressChanged.connect(self._downloadProgressChanged)
dt.start()
elif phase == 2:
# indeterminate
self._ui.setProgressIndeterminate(True)
self._setStatus("Installing MacGPG...", progress=True)
dmgFile = dt.target.name
dt.close()
st = ShellThread(getValidQtParent(), self.logger, [get_settings().get_resource('bin', 'mac_gpg_installer.sh'), dmgFile], context=dmgFile, quiet=False)
st.finished.connect(partial(self._install_gpg_finished, 2))
st.start()
elif phase == 3:
dmgFile = dt.context
if os.path.exists(dmgFile):
os.remove(dmgFile)
self._ui.setProgressIndeterminate(False)
if dt.exitCode == 0:
self._setStatus("MacGPG installed successfully.")
else:
self._setStatus("Error installing MacGPG.", err=True)
if dt.pErr:
self.logger.error("Error installing MacGPG.\nConsole output: %s", dt.pErr.strip())
self._updateCheckButtonText()
self._ui.setInteractive(True)
def changeNextLunchTime(self, begin = None, end = None):
if begin == None:
if self.mainWindow == None:
getCoreLogger().error("mainWindow is not initialized")
return
from lunchinator.timespan_input_dialog import TimespanInputDialog
dialog = TimespanInputDialog(self.mainWindow, "Change Lunch Time", "When are you free for lunch today?", get_settings().get_next_lunch_begin(), get_settings().get_next_lunch_end())
dialog.exec_()
if dialog.result() == QDialog.Accepted:
get_settings().set_next_lunch_time(dialog.getBeginTimeString(), dialog.getEndTimeString())
else:
return
else:
get_settings().set_next_lunch_time(begin, end)
if self.resetNextLunchTimeTimer != None:
self.resetNextLunchTimeTimer.stop()
self.resetNextLunchTimeTimer.deleteLater()
td = get_settings().get_next_lunch_reset_time()
if td > 0:
self.resetNextLunchTimeTimer = QTimer(getValidQtParent())
self.resetNextLunchTimeTimer.timeout.connect(self._resetNextLunchTime)
self.resetNextLunchTimeTimer.setSingleShot(True)
self.resetNextLunchTimeTimer.start(abs(td) + 1000)
get_server().call_info()
def checkForUpdate(self):
self._setStatus("Checking for update...")
from lunchinator.callables import AsyncCall
AsyncCall(getValidQtParent(),
self.logger,
self._gitHandler.needsPull,
self._checkUpdateSuccess,
self._checkUpdateError)(returnReason=True)
def _checkForUpdates(self):
if self._ui.getTable().model().rowCount() == 0:
return
from lunchinator.callables import AsyncCall
self._setStatus("Checking for updates...", True)
AsyncCall(getValidQtParent(),
self.logger,
self._checkAllRepositories,
self._processUpdates,
self._checkingError)()
def create_widget(self, parent):
from PyQt4.QtGui import QTextEdit, QSizePolicy
from lunchinator.callables import AsyncCall
self._textview = QTextEdit(parent)
self._textview.setLineWrapMode(QTextEdit.WidgetWidth)
self._textview.setReadOnly(True)
self._textview.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
AsyncCall(getValidQtParent(), self.logger, self._downloadText, self._updateText, self._errorDownloadingText)()
return self._textview
def checkForUpdate(self):
if not self._has_gpg():
# user clicked on "Install GPG"
return self._installGPG()
self._setStatus("Checking %s for Update..."%self._urlBase)
if self._getCheckURLBase() == None:
self._setStatus("Auto Update does not work on your OS yet.", True)
return
url = self._getCheckURLBase() + "/latest_version.asc"
version_download = DownloadThread(getValidQtParent(), self.logger, url)
version_download.success.connect(self._versionInfoDownloaded)
version_download.error.connect(self._errorDownloading)
version_download.finished.connect(version_download.deleteLater)
version_download.start()
def activate(self):
iface_general_plugin.activate(self)
try:
from PyQt4.QtCore import QTimer
from online_update.appupdate.git_update import GitUpdateHandler
from online_update.appupdate.mac_update import MacUpdateHandler
from online_update.appupdate.external_update import ExternalUpdateHandler
from online_update.appupdate.win_update import WinUpdateHandler
from online_update.appupdate.app_update_handler import AppUpdateHandler
from online_update.repoupdate.repo_update_handler import RepoUpdateHandler
self._activated = True
except ImportError:
self._activated = False
self.logger.warning("ImportError, cannot activate Auto Update")
return
if GitUpdateHandler.appliesToConfiguration(self.logger):
self._appUpdateHandler = GitUpdateHandler(self.logger)
elif MacUpdateHandler.appliesToConfiguration(self.logger):
self._appUpdateHandler = MacUpdateHandler(self.logger, self.hidden_options["check_url"])
elif ExternalUpdateHandler.appliesToConfiguration(self.logger):
self._appUpdateHandler = ExternalUpdateHandler(self.logger)
elif WinUpdateHandler.appliesToConfiguration(self.logger):
self._appUpdateHandler = WinUpdateHandler(self.logger, self.hidden_options["check_url"])
else:
self._appUpdateHandler = AppUpdateHandler(self.logger)
self._repoUpdateHandler = RepoUpdateHandler(self.logger)
self._appUpdateHandler.activate()
self._repoUpdateHandler.activate()
get_notification_center().connectInstallUpdates(self.installUpdates)
get_notification_center().connectRepositoriesChanged(self._repoUpdateHandler.checkForUpdates)
if lunchinator_has_gui():
self._scheduleTimer = QTimer(getValidQtParent())
self._scheduleTimer.timeout.connect(self.checkForUpdate)
self._scheduleTimer.start(online_update.CHECK_INTERVAL)
def _versionInfoDownloaded(self, thread, _url):
try:
signedString = thread.getResult()
except:
self._setStatus("Version info not available", True)
return
self.logger.debug("Update: Got version info, checking signature %s", signedString)
ver_result = False
try:
ver_result = self._verifySignature(signedString)
except:
self.logger.exception("Error verifying signature")
self._setStatus("Signature could not be verified because of unknown error", True)
return
if not ver_result:
self._setStatus("Signature could not be verified", True)
return
self.logger.debug("Updater: Signature OK, checking version info")
for l in signedString.splitlines():
info = l.split(":", 1)
if len(info) > 1:
self._version_info[info[0]] = info[1].strip()
if not self._version_info.has_key("URL") or not self._version_info.has_key("Commit Count"):
self._setStatus("Version Info corrupt - URL and/or Commit Count missing", True)
self.logger.debug(str(self._version_info))
return
else:
try:
self._version_info["Commit Count"] = int(self._version_info["Commit Count"])
except:
self._setStatus("Commit Count has wrong format: " % self._version_info["Commit Count"], True)
return
self._updateVersionLabel()
self._installer_url = self._getCheckURLBase() + self._version_info["URL"]
self._local_installer_file = os.path.join(get_settings().get_main_config_dir(), self._installer_url.rsplit('/', 1)[1])
if self._hasNewVersion() and u"Change Log" in self._version_info:
try:
changeLog = json.loads(self._version_info[u"Change Log"])
self._setChangeLog(changeLog)
except:
self.logger.exception("Error reading change log.")
self._setChangeLog(["Error loading change log"])
if self._hasNewVersion():
# check if we already downloaded this version before
if not self._checkHash(errorOnBadHash=False):
self._setStatus("New version %s available, downloading ..." % (self._getDownloadedVersion()), progress=True)
installer_download = DownloadThread(getValidQtParent(), self.logger, self._installer_url, target=open(self._local_installer_file, "wb"), progress=True)
installer_download.progressChanged.connect(self._downloadProgressChanged)
installer_download.success.connect(self._installerDownloaded)
installer_download.error.connect(self._errorDownloading)
installer_download.finished.connect(installer_download.deleteLater)
installer_download.start()
else:
self._setStatus("No new version available")
def checkForUpdates(self):
AsyncCall(getValidQtParent(),
self.logger,
get_settings().get_plugin_repositories().checkForUpdates)()
