369 lines
14 KiB
Python
Executable File
369 lines
14 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright (c) 2019-2020 by Silvan Calarco <silvan.calarco@mambasoft.it>
|
|
# Release under the terms of the GPL version 3 license
|
|
|
|
from PyQt5 import QtCore
|
|
from PyQt5 import QtGui
|
|
from PyQt5.QtCore import pyqtProperty
|
|
from PyQt5 import QtCore, QtWidgets
|
|
from PyQt5 import QtWidgets, uic
|
|
from pathlib import Path
|
|
import gettext
|
|
import subprocess
|
|
import os
|
|
|
|
import gi
|
|
gi.require_version('PackageKitGlib', '1.0')
|
|
from gi.repository import PackageKitGlib as packagekit
|
|
|
|
DATADIR = os.path.dirname(os.path.realpath((__file__))) + "/"
|
|
|
|
|
|
class MambabaseWizard(QtWidgets.QWizard):
|
|
def __init__(self, parent=None):
|
|
super(MambabaseWizard, self).__init__(parent)
|
|
self.welcomePage = WelcomePage(self)
|
|
self.addPage(self.welcomePage)
|
|
self.selectGroupsPage = SelectGroupsPage(self)
|
|
self.addPage(self.selectGroupsPage)
|
|
self.selectExtraPage = SelectExtraPage(self)
|
|
self.addPage(self.selectExtraPage)
|
|
self.installationPage = InstallationPage(self)
|
|
self.addPage(self.installationPage)
|
|
self.setWindowTitle(_("openmamba base network installations") +
|
|
" - openmamba.org")
|
|
self.setFixedSize(571,465)
|
|
self.currentIdChanged.connect(self.currentIdChangedSlot)
|
|
self.prepareThread = PrepareThread(self)
|
|
self.installThread = InstallThread(self, self.selectGroupsPage.pkggroups)
|
|
|
|
def currentIdChangedSlot(self, currentId):
|
|
if currentId == 0:
|
|
self.prepareThread.start()
|
|
elif currentId == 3:
|
|
self.installThread.start()
|
|
|
|
|
|
class PrepareThread(QtCore.QThread):
|
|
parent = None
|
|
doneSignal = QtCore.pyqtSignal()
|
|
updateProgressSignal = QtCore.pyqtSignal(dict)
|
|
|
|
def __init__(self, parent=None):
|
|
super(PrepareThread, self).__init__(parent)
|
|
self.parent = parent
|
|
self.doneSignal.connect(parent.welcomePage.completeChanged)
|
|
self.updateProgressSignal.connect(
|
|
parent.welcomePage.updateProgressSlot)
|
|
|
|
def run(self):
|
|
# Update packages list
|
|
self.updateProgressSignal.emit({ 'value': 5,
|
|
'label': _("Checking installed packages...")})
|
|
self.parent.selectGroupsPage.loadPkgGroups()
|
|
self.updateProgressSignal.emit({ 'value': 55,
|
|
'label': _("Checking installed extra components...")})
|
|
self.parent.selectExtraPage.setExtras()
|
|
self.updateProgressSignal.emit({ 'value': 100,
|
|
'label': _("Done. Please, press the Next button to continue.")})
|
|
# Enable back and next buttons
|
|
self.parent.welcomePage.done = True
|
|
self.doneSignal.emit()
|
|
|
|
|
|
class InstallThread(QtCore.QThread):
|
|
parent = None
|
|
doneSignal = QtCore.pyqtSignal()
|
|
updateProgressSignal = QtCore.pyqtSignal(dict)
|
|
pkggroups = {}
|
|
|
|
def __init__(self, parent=None, pkggroups={}):
|
|
super(InstallThread, self).__init__(parent)
|
|
self.parent = parent
|
|
self.pkggroups = pkggroups
|
|
self.doneSignal.connect(parent.installationPage.completeChanged)
|
|
self.updateProgressSignal.connect(
|
|
parent.installationPage.updateProgressSlot)
|
|
|
|
def run(self):
|
|
install = {}
|
|
install_extras = {}
|
|
parent = self.parent
|
|
|
|
# Disable back and next buttons
|
|
parent.installationPage.done = False
|
|
self.doneSignal.emit()
|
|
self.updateProgressSignal.emit(
|
|
{ 'value': 1, 'label': _("Starting installation..."),
|
|
'details': _("Starting installation...")})
|
|
|
|
# Update packages list
|
|
self.updateProgressSignal.emit({ 'value': 5,
|
|
'label': _("Updating packages list..."),
|
|
'details': _("Updating packages list...")})
|
|
|
|
result = subprocess.run(['pkcon', 'refresh'],
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
if result.returncode == 0:
|
|
if result.stdout:
|
|
self.updateProgressSignal.emit({
|
|
'details': result.stdout.decode('UTF-8')})
|
|
else:
|
|
if result.stderr:
|
|
self.updateProgressSignal.emit({
|
|
'details': result.stderr.decode('UTF-8')})
|
|
|
|
# Perform system update
|
|
self.updateProgressSignal.emit({ 'value': 10,
|
|
'label': _("Updating installed packages..."),
|
|
'details': _("Updating installed packages...")})
|
|
|
|
result = subprocess.run(['pkcon', 'update', '-y'],
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
if result.returncode == 0:
|
|
if result.stdout:
|
|
self.updateProgressSignal.emit({
|
|
'details': result.stdout.decode('UTF-8')})
|
|
else:
|
|
if result.stderr:
|
|
self.updateProgressSignal.emit({
|
|
'details': result.stderr.decode('UTF-8')})
|
|
|
|
self.updateProgressSignal.emit({ 'value': 20 })
|
|
|
|
arch = os.uname()[4]
|
|
if arch == 'i686':
|
|
arch = 'i586'
|
|
elif arch[:3] == 'arm':
|
|
arch = 'arm'
|
|
client = packagekit.Client()
|
|
|
|
# Install requested package groups
|
|
for group in parent.selectGroupsPage.groups_checkboxes:
|
|
install[group] = \
|
|
parent.selectGroupsPage.groups_checkboxes[group].isChecked() \
|
|
and parent.selectGroupsPage.groups_checkboxes[group].isEnabled()
|
|
|
|
for inst in install:
|
|
if install[inst]:
|
|
self.updateProgressSignal.emit({
|
|
'label': _("Installing %s group packages..." % inst),
|
|
'details': _("Installing %s group packages..." % inst)})
|
|
for pkg in self.pkggroups[inst].split():
|
|
result =client.resolve(0, (pkg,), None,
|
|
self.packagekit_progress_cb, None)
|
|
pkgs = result.get_package_array()
|
|
for p in pkgs:
|
|
if 'installed' in p.get_data().split(':'):
|
|
self.updateProgressSignal.emit({
|
|
'details': _("Package %s is already installed" % pkg)})
|
|
break
|
|
if p.get_arch() != arch:
|
|
continue
|
|
packageid = p.get_name() + ';' + p.get_version() + ';' \
|
|
+ p.get_arch() + ';' + p.get_data()
|
|
self.updateProgressSignal.emit({
|
|
'details': _("Installing package %s" % pkg)})
|
|
client.install_packages(False, (packageid, ), None,
|
|
self.packagekit_progress_cb, p.get_name())
|
|
|
|
# Install requested extra packages
|
|
for extra in parent.selectExtraPage.extra_checkboxes:
|
|
install_extras[extra] = \
|
|
parent.selectExtraPage.extra_checkboxes[extra].isChecked() \
|
|
and parent.selectExtraPage.extra_checkboxes[extra].isEnabled()
|
|
|
|
for extra in install_extras:
|
|
if install_extras[extra]:
|
|
self.updateProgressSignal.emit({
|
|
'label': _("Installing %s extra component..." % extra),
|
|
'details': _("Installing %s extra component..." % extra)})
|
|
if extra == 'nvidia':
|
|
result = subprocess.run([
|
|
'/usr/share/openmamba/mambabase/nvidia-autoselect-driver',
|
|
'-i'],
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
else:
|
|
result = subprocess.run(['/usr/bin/openmamba-netsrpms', extra],
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
if result.returncode == 0:
|
|
if result.stdout:
|
|
self.updateProgressSignal.emit({
|
|
'details': result.stdout.decode('UTF-8')})
|
|
else:
|
|
if result.stderr:
|
|
self.updateProgressSignal.emit({
|
|
'details': result.stderr.decode('UTF-8')})
|
|
|
|
|
|
# Finished
|
|
self.updateProgressSignal.emit({ 'value': 100,
|
|
'label': _("Installation finished!"),
|
|
'details': _("Installation finished!")})
|
|
|
|
# Remove any autostart file
|
|
try:
|
|
file_path = Path.home() / ".config/autostart/mambabase.desktop"
|
|
file_path.unlink()
|
|
except:
|
|
None
|
|
|
|
# Enable back and next buttons
|
|
parent.installationPage.done = True
|
|
self.doneSignal.emit()
|
|
|
|
def packagekit_progress_cb(self, status, typ, data=None):
|
|
if status.get_property('package'):
|
|
self.updateProgressSignal.emit({
|
|
'label': _("Installing %s package (%s)..." %
|
|
(status.get_property('package').get_name(),
|
|
str(status.get_percentage())))})
|
|
|
|
|
|
class WelcomePage(QtWidgets.QWizardPage):
|
|
done = False
|
|
|
|
def __init__(self, parent=None):
|
|
super(WelcomePage, self).__init__(parent)
|
|
uic.loadUi(DATADIR + "WelcomePage.ui", self)
|
|
self.show()
|
|
|
|
def isComplete(self):
|
|
return self.done
|
|
|
|
@QtCore.pyqtSlot(dict)
|
|
def updateProgressSlot(self, dict):
|
|
if 'value' in dict:
|
|
self.progressBar.setValue(dict['value'])
|
|
if 'label' in dict:
|
|
self.progressLabel.setText(dict['label'])
|
|
|
|
|
|
class SelectGroupsPage(QtWidgets.QWizardPage):
|
|
groups_checkboxes = {}
|
|
pkggroups = {}
|
|
|
|
def __init__(self, parent=None):
|
|
super(SelectGroupsPage, self).__init__(parent)
|
|
uic.loadUi(DATADIR + "SelectGroupsPage.ui", self)
|
|
self.show()
|
|
|
|
def loadPkgGroups(self):
|
|
self.groups_checkboxes = {
|
|
'base': self.inst_base,
|
|
'office': self.inst_office,
|
|
'multimedia_players': self.inst_players,
|
|
'multimedia_editing': self.inst_multimedia_editing,
|
|
'internet': self.inst_internet,
|
|
'graphics': self.inst_graphics,
|
|
'games': self.inst_games,
|
|
'virtualization': self.inst_virtualization,
|
|
'server': self.inst_server
|
|
}
|
|
#'devel': self.inst_devel
|
|
# Load packages group db into a dict
|
|
result = subprocess.run([DATADIR + "mambabase-pkggroups-parser.sh"],
|
|
stdout=subprocess.PIPE)
|
|
lines = result.stdout.decode('UTF-8').splitlines()
|
|
for line in lines:
|
|
if line:
|
|
(key, val) = line.split("=")
|
|
self.pkggroups[key] = val
|
|
|
|
# Check for groups already installed
|
|
client = packagekit.Client()
|
|
for group in self.groups_checkboxes:
|
|
group_installed = True
|
|
if group in self.pkggroups:
|
|
for pkg in self.pkggroups[group].split():
|
|
result = client.resolve(0, (pkg,), None,
|
|
self.packagekit_progress_cb, None)
|
|
pkgs_found = result.get_package_array()
|
|
package_installed = False
|
|
for p in pkgs_found:
|
|
if 'installed' in p.get_data().split(':'):
|
|
package_installed = True
|
|
break
|
|
if not package_installed and len(pkgs_found) > 0:
|
|
group_installed = False
|
|
elif len(pkgs_found) == 0:
|
|
print(_("WARNING: package %s from group %s not found in repositories"
|
|
% (pkg, group)))
|
|
if group_installed:
|
|
self.groups_checkboxes[group].setChecked(True)
|
|
self.groups_checkboxes[group].setEnabled(False)
|
|
|
|
def packagekit_progress_cb(self, status, typ, data=None):
|
|
pass
|
|
|
|
|
|
class SelectExtraPage(QtWidgets.QWizardPage):
|
|
extra_checkboxes = {}
|
|
|
|
def __init__(self, parent=None):
|
|
super(SelectExtraPage, self).__init__(parent)
|
|
uic.loadUi(DATADIR + "SelectExtraPage.ui", self)
|
|
self.setCommitPage(True)
|
|
self.show()
|
|
|
|
def setExtras(self):
|
|
self.extra_checkboxes = {
|
|
'nvidia': self.inst_nvidia,
|
|
'broadcom_sta': self.inst_broadcom_sta,
|
|
'b43-firmware': self.inst_b43,
|
|
'flashplugin': self.inst_flash,
|
|
'chromium-pepper-flash': self.inst_pepperflash,
|
|
'msttcorefonts': self.inst_msttcf,
|
|
'win32codecs': self.inst_codecs,
|
|
'sun-java': self.inst_java,
|
|
'virtualbox-extension-pack': self.inst_virtualbox,
|
|
'chromium-widevine': self.inst_widevine
|
|
}
|
|
# 'fglrx': self.inst_fglrx,
|
|
# 'fglrx_legacy': self.inst_fglrx_legacy,
|
|
# 'skype': self.inst_skype,
|
|
# 'spotify': self.inst_spotify,
|
|
for extra in self.extra_checkboxes:
|
|
result = subprocess.run(['/usr/bin/openmamba-netsrpms', '-c', extra],
|
|
stdout=subprocess.PIPE)
|
|
if result.returncode < 2:
|
|
self.extra_checkboxes[extra].setChecked(True)
|
|
self.extra_checkboxes[extra].setEnabled(False)
|
|
|
|
|
|
class InstallationPage(QtWidgets.QWizardPage):
|
|
done = False
|
|
|
|
def __init__(self, parent=None):
|
|
super(InstallationPage, self).__init__(parent)
|
|
uic.loadUi(DATADIR + "InstallationPage.ui", self)
|
|
self.setCommitPage(True)
|
|
self.show()
|
|
|
|
def isComplete(self):
|
|
if self.done:
|
|
self.installPageTitle.setText(
|
|
_('<html><head/><body><p align="center">' +
|
|
'<span style="font-size:14pt; font-weight:600;">' +
|
|
'All done!</span></p></body></html>'))
|
|
return self.done
|
|
|
|
@QtCore.pyqtSlot(dict)
|
|
def updateProgressSlot(self, dict):
|
|
if 'value' in dict:
|
|
self.progressBar.setValue(dict['value'])
|
|
if 'label' in dict:
|
|
self.progressLabel.setText(dict['label'])
|
|
if 'details' in dict:
|
|
self.progressDetails.append("<br/>" + dict['details'])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
import sys
|
|
app = QtWidgets.QApplication(sys.argv)
|
|
app.setWindowIcon(QtGui.QIcon(DATADIR + "mambabase.png"))
|
|
gettext.install('mambabase', '/usr/share/locale')
|
|
wizard = MambabaseWizard()
|
|
wizard.show()
|
|
sys.exit(app.exec_())
|