mirror of
https://github.com/Snigdha-OS/snigdhaos-blackbox.git
synced 2026-02-04 21:43:55 +01:00
892 lines
32 KiB
Python
892 lines
32 KiB
Python
#!/bin/python
|
|
|
|
import os
|
|
from os import makedirs
|
|
import sys
|
|
import psutil
|
|
import gi
|
|
import subprocess
|
|
import logging
|
|
from logging.handlers import TimedRotatingFileHandler
|
|
from threading import Thread
|
|
import datetime
|
|
from datetime import datetime
|
|
from datetime import timedelta
|
|
from datetime import time
|
|
import shutil
|
|
import Functions as fn
|
|
|
|
from Settings import Settings
|
|
from Package import Package
|
|
from ui.MessageDialog import MessageDialog
|
|
|
|
|
|
gi.require_version("Gtk" "3.0") # GTK 2.0 is dead!
|
|
from gi.repository import GLib, Gtk
|
|
|
|
# NOTE: Base Directory
|
|
base_dir = os.path.dirname(os.path.realpath(__file__))
|
|
|
|
# NOTE: Global Variables
|
|
sudo_username = os.getlogin()
|
|
home = "/home/" + str(sudo_username)
|
|
path_dir_cache = base_dir + "/cache/"
|
|
packages = []
|
|
distr = id()
|
|
blackbox_lockfile = "/tmp/blackbox.lock"
|
|
blackbox_pidfile = "/tmp/blackbox.pid"
|
|
process_timeout = 300 # NOTE: process time out has been set to 5 mins.
|
|
snigdhaos_mirrorlist = "/etc/pacman.d/snigdhaos-mirrorlist"
|
|
|
|
# NOTE: pacman settings
|
|
pacman_conf = "/etc/pacman.conf"
|
|
pacman_conf_backup = "/etc/pacman.conf.bak" # NOTE: Bak stands for backup
|
|
pacman_logfile = "/var/log/pacman.log"
|
|
pacman_lockfile = "/var/lib/pacman/db.lck"
|
|
pacman_cache_dir = "/var/cache/pacman/pkg/"
|
|
|
|
# NOTE: Snigdha OS Mirror Config
|
|
snigdhaos_core = [
|
|
"[snigdhaos-core]"
|
|
"SigLevel = PackageRequired DatabaseNever"
|
|
"Include = /etc/pacman.d/snigdhaos-mirrorlist"
|
|
]
|
|
snigdhaos_extra = [
|
|
"[snigdhaos-extra]"
|
|
"SigLevel = PackageRequired DatabaseNever"
|
|
"Include = /etc/pacman.d/snigdhaos-mirrorlist"
|
|
]
|
|
|
|
# NOTE: BlackBox Specific
|
|
log_dir = "/var/log/blackbox/"
|
|
config_dir = "%s/.config/blackbox" % home
|
|
config_file = "%s/blackbox.yaml" % config_dir # NOTE: It is already on $pwd
|
|
event_log_file = "%s/event.log" % log_dir
|
|
export_dir = "%s/blackbox-exports" % home
|
|
|
|
# NOTE: Permissions specified here
|
|
|
|
def permissions(dst):
|
|
try:
|
|
# NOTE : Use try-catch block so that we can trace any error!
|
|
groups = subprocess.run(
|
|
["sh", "-c", "id " + sudo_username],
|
|
shell=False,
|
|
stdout=subprocess.PIPE, # NOTE: Standard Output
|
|
stderr=subprocess.STDOUT, # NOTE: Standard Error Output
|
|
)
|
|
for i in groups.stdout.decode().split(" "):
|
|
if "gid" in i:
|
|
g = i.split("(")[1]
|
|
group = g.replace(")", "").strip() # NOTE: replace with nothing!
|
|
subprocess.call(["chown", "-R", sudo_username + ":" + group, dst], shell=False)
|
|
except Exception as e:
|
|
logger.error(e)
|
|
|
|
# NOTE: Creating Log, Export and Config Directory:
|
|
try:
|
|
if not os.path.exists(log_dir):
|
|
makedirs(log_dir)
|
|
if not os.path.exists(export_dir):
|
|
makedirs(export_dir)
|
|
if not os.path.exists(config_dir):
|
|
makedirs(config_dir)
|
|
|
|
permissions(export_dir)
|
|
permissions(config_dir)
|
|
|
|
print("[INFO] Log Directory: %s" % log_dir)
|
|
print("[INFO] Export Directory: %s" % export_dir)
|
|
print("[INFO] Config Directory: %s" % config_dir)
|
|
|
|
except os.error as oserror:
|
|
print("[ERROR] Exception: %s" % oserror)
|
|
sys.exit(1)
|
|
|
|
# NOTE: Read Config File dst: $HOME/.config/blackbox/blackbox.yaml
|
|
# NOTE: Initiate logger
|
|
try:
|
|
settings = Settings(False, False)
|
|
settings_config = settings.read_config_file()
|
|
logger = logging.getLogger("logger")
|
|
# NOTE: Create a console handler
|
|
ch = logging.StreamHandler()
|
|
# NOTE: Rotate the fucking event log!
|
|
tfh = TimedRotatingFileHandler(
|
|
event_log_file,
|
|
encoding="UTF-8",
|
|
delay=False,
|
|
when="W4",
|
|
)
|
|
|
|
if settings_config:
|
|
debug_logging_enabled = None
|
|
debug_logging_enabled = settings_config[
|
|
"Debug Logging"
|
|
]
|
|
|
|
if debug_logging_enabled is not None and debug_logging_enabled is True:
|
|
logger.setLevel(logging.DEBUG)
|
|
ch.setLevel(logging.DEBUG)
|
|
tfh.setLevel(level=logging.DEBUG)
|
|
else:
|
|
logger.setLevel(logging.INFO)
|
|
ch.setLevel(logging.INFO)
|
|
tfh.setLevel(level=logging.INFO)
|
|
else:
|
|
logger.setLevel(logging.INFO)
|
|
ch.setLevel(logging.INFO)
|
|
tfh.setLevel(level=logging.INFO)
|
|
# NOTE: Docs -> https://docs.python.org/3/library/logging.handlers.html#timedrotatingfilehandler
|
|
formatter = logging.Formatter(
|
|
"%(asctime)s:%(levelname)s > %(message)s",
|
|
"%Y-%m-%d %H:%M:%S"
|
|
)
|
|
# NOTE : Call formatter to ch & tfh
|
|
ch.setFormatter(formatter)
|
|
tfh.setFormatter(formatter)
|
|
# NOTE: Append ch to logger
|
|
logger.addHandler(ch)
|
|
# NOTE: Append File Handler to logger
|
|
logger.addHandler(tfh)
|
|
|
|
except Exception as e:
|
|
print("[ERROR] Failed: %s" % e)
|
|
|
|
# NOTE : On app close create package file
|
|
def _on_close_create_package_file():
|
|
try:
|
|
logger.info("App cloding saving currently installed package to file")
|
|
package_file = "%s-packages.txt" % datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
|
|
logger.info("Saving: %s%s" %(log_dir, package_file))
|
|
cmd = [
|
|
"pacman",
|
|
"-Q",
|
|
]
|
|
with subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
bufsize=1,
|
|
universal_newlines=True,
|
|
) as process:
|
|
with open("%s/%s" % (log_dir, package_file), "w") as f:
|
|
for line in process.stdout:
|
|
f.write("%s" %line)
|
|
except Exception as e:
|
|
logger.error("[ERROR] Exception: %s" % e)
|
|
|
|
# NOTE: Global Functions
|
|
|
|
def _get_position(lists, value):
|
|
data = [
|
|
string for string in lists if value in string
|
|
]
|
|
position = lists.index(data[0])
|
|
return position
|
|
|
|
def is_file_stale(filepath, stale_days, stale_hours, stale_minutes):
|
|
now = datetime.now()
|
|
stale_datetime = now - timedelta(
|
|
days=stale_days,
|
|
hours=stale_hours,
|
|
minutes=stale_minutes,
|
|
)
|
|
if os.path.exists(filepath):
|
|
file_created = datetime.fromtimestamp(
|
|
os.path.getctime(filepath)
|
|
)
|
|
if file_created < stale_datetime:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
# NOTE : Pacman
|
|
def sync_package_db():
|
|
try:
|
|
sync_str = [
|
|
"pacman",
|
|
"-Sy",
|
|
]
|
|
logger.info(
|
|
"Synchronizing Package Database..."
|
|
)
|
|
process_sync = subprocess.run(
|
|
sync_str,
|
|
shell=False,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
timeout=process_timeout,
|
|
)
|
|
if process_sync.returncode == 0:
|
|
return None
|
|
else:
|
|
if process_sync.stdout:
|
|
out = str(process_sync.stdout.decode("UTF-8"))
|
|
logger.error(out)
|
|
return out
|
|
except Exception as e:
|
|
logger.error(
|
|
"[ERROR] Exception: %s" % e
|
|
)
|
|
|
|
def sync_file_db():
|
|
try:
|
|
sync_str = [
|
|
"pacman",
|
|
"-Fy",
|
|
]
|
|
logger.info(
|
|
"Synchronizing File Database..."
|
|
)
|
|
process_sync = subprocess.run(
|
|
sync_str,
|
|
shell=False,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
timeout=process_timeout,
|
|
|
|
)
|
|
if process_sync.returncode == 0:
|
|
return None
|
|
else:
|
|
if process_sync.stdout:
|
|
out = str(process_sync.stdout.decode("UTF-8"))
|
|
logger.error(out)
|
|
return out
|
|
except Exception as e:
|
|
logger.error(
|
|
"[ERROR] Exception: %s" % e
|
|
)
|
|
|
|
# NOTE: Installation & Uninstallation Process
|
|
def start_subprocess(
|
|
self,
|
|
cmd,
|
|
progress_dialog,
|
|
action,
|
|
pkg,
|
|
widget
|
|
):
|
|
try:
|
|
self.switch_package_version.set_sensitive(False)
|
|
self.switch_snigdhaos_keyring.set_sensitive(False)
|
|
self.switch_snigdhaos_mirrorlist.set_sensitive(False)
|
|
|
|
widget.set_sensitive(False)
|
|
|
|
process_stdout_lst = []
|
|
process_stdout_lst.append(
|
|
"Command = %s\n\n" % " ".join(cmd)
|
|
)
|
|
with subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
bufsize=1,
|
|
universal_newlines=True,
|
|
) as process:
|
|
if progress_dialog is not None:
|
|
progress_dialog.pkg_dialog_closed = False
|
|
self.in_progress = True
|
|
if (
|
|
progress_dialog is not None and progress_dialog.pkg_dialog_closed is False
|
|
):
|
|
line = (
|
|
"Pacman Processing: %s Package: %s \n\n Command: %s\n\n" % (action, pkg.name, " ".join(cmd))
|
|
)
|
|
# DOC: https://docs.gtk.org/glib/const.PRIORITY_DEFAULT.html
|
|
GLib.idle_add(
|
|
update_progress_textview,
|
|
self,
|
|
line,
|
|
progress_dialog,
|
|
priority=GLib.PRIORITY_DEFAULT,
|
|
)
|
|
logger.debug("Pacman is processing the request.")
|
|
|
|
while True:
|
|
if process.poll() is not None:
|
|
break
|
|
if (
|
|
progress_dialog is not None and progress_dialog.pkg_dialog_closed is False
|
|
):
|
|
for line in process.stdout:
|
|
GLib.idle_add(
|
|
update_progress_textview,
|
|
self,
|
|
line,
|
|
progress_dialog,
|
|
priority=GLib.PRIORITY_DEFAULT,
|
|
)
|
|
process_stdout_lst.append(line)
|
|
time.sleep(0.3)
|
|
else:
|
|
for line in process.stdout:
|
|
process_stdout_lst.append(line)
|
|
time.sleep(1)
|
|
returncode = None
|
|
returncode = process.poll()
|
|
|
|
if returncode is not None:
|
|
logger.info(
|
|
"Pacman process completion: %s" % " ".join(cmd)
|
|
)
|
|
GLib.idle_add(
|
|
refresh_ui,
|
|
self,
|
|
action,
|
|
widget,
|
|
pkg,
|
|
progress_dialog,
|
|
process_stdout_lst,
|
|
priority=GLib.PRIORITY_DEFAULT,
|
|
)
|
|
else:
|
|
logger.error(
|
|
"Pacman process failed to run %s" % " ".join(cmd)
|
|
)
|
|
|
|
except TimeoutError as terr:
|
|
# print(e)
|
|
logger.error(
|
|
"Timeout Error in %s : %s" % (action, terr)
|
|
)
|
|
process.terminate()
|
|
if progress_dialog is not None:
|
|
progress_dialog.btn_package_progress_close.set_sensitive(True)
|
|
self.switch_package_version.set_sensitive(True)
|
|
self.switch_snigdhaos_keyring.set_sensitive(True)
|
|
self.switch_snigdhaos_mirrorlist.set_sensitive(True)
|
|
|
|
except SystemError as syerr:
|
|
logger.error(
|
|
"Timeout Error in %s : %s" % (action, syerr)
|
|
)
|
|
process.terminate()
|
|
if progress_dialog is not None:
|
|
progress_dialog.btn_package_progress_close.set_sensitive(True)
|
|
self.switch_package_version.set_sensitive(True)
|
|
self.switch_snigdhaos_keyring.set_sensitive(True)
|
|
self.switch_snigdhaos_mirrorlist.set_sensitive(True)
|
|
|
|
def refresh_ui(
|
|
self,
|
|
action,
|
|
switch,
|
|
pkg,
|
|
progress_dialog,
|
|
process_stdout_lst,
|
|
):
|
|
self.switch_package_version.set_sensitive(False)
|
|
self.switch_snigdhaos_keyring.set_sensitive(False)
|
|
self.switch_snigdhaos_mirrorlist.set_sensitive(False)
|
|
|
|
logger.debug("Checking if the package installed..." % pkg.name)
|
|
installed = check_package_installed(pkg.name)
|
|
if progress_dialog is not None:
|
|
progress_dialog.btn_package_progress_close.set_sentitive(True)
|
|
if installed is True and action == "install":
|
|
logger.debug("Toggle switch state = True")
|
|
switch.set_sensitive(True)
|
|
switch.set_state(True)
|
|
switch.set_active(True)
|
|
if progress_dialog is not None:
|
|
if progress_dialog.pkg_dialog_closed is False:
|
|
progress_dialog.set_title(
|
|
"Package installed: %s" % pkg.name
|
|
)
|
|
progress_dialog.infobar.set_name(
|
|
"infobar_info"
|
|
)
|
|
content = progress_dialog.infobar.get_content_area()
|
|
if content is not None:
|
|
for widget in content.get_children():
|
|
content.remove(widget)
|
|
# DOCS: https://docs.gtk.org/gtk3/class.Label.html
|
|
lbl_install = Gtk.Label(xalign=0, yalign=0)
|
|
# DOCS: https://stackoverflow.com/questions/40072104/multi-color-text-in-one-gtk-label
|
|
lbl_install.set_markup(
|
|
"<b>Package %s installed.</b>" % pkg.name
|
|
)
|
|
content.add(lbl_install)
|
|
if self.timeout_id is not None:
|
|
# DOCS: https://gtk-rs.org/gtk-rs-core/stable/0.14/docs/glib/source/fn.source_remove.html
|
|
GLib.source_remove(self.timeout_id)
|
|
self.timeout_id = None
|
|
self.timeout_id = GLib.timeout_add(
|
|
100,
|
|
reveal_infobar,
|
|
self,
|
|
progress_dialog,
|
|
)
|
|
if installed is False and action == "install":
|
|
logger.debug("Toggle switch state = False")
|
|
if progress_dialog is not None:
|
|
switch.set_sensitive(True)
|
|
switch.set_state(False)
|
|
switch.set_active(False)
|
|
if progress_dialog.pkg_dialog_closed is False:
|
|
progress_dialog.set_title("%s install failed" % pkg.name)
|
|
progress_dialog.infobar.set_name("infobar_error")
|
|
content = progress_dialog.infobar.get_content_area()
|
|
if content is not None:
|
|
for widget in content.get_children():
|
|
content.remove(widget)
|
|
lbl_install = Gtk.Label(xalign=0, yalign=0)
|
|
lbl_install.set_markup(
|
|
"<b>Package %s installed failed.</b>" % pkg.name
|
|
)
|
|
content.add(lbl_install)
|
|
if self.timeout_id is not None:
|
|
# DOCS: https://gtk-rs.org/gtk-rs-core/stable/0.14/docs/glib/source/fn.source_remove.html
|
|
GLib.source_remove(self.timeout_id)
|
|
self.timeout_id = None
|
|
self.timeout_id = GLib.timeout_add(
|
|
100,
|
|
reveal_infobar,
|
|
self,
|
|
progress_dialog,
|
|
)
|
|
else:
|
|
logger.debug(" ".join(process_stdout_lst))
|
|
message_dialog = MessageDialog(
|
|
"Errors occured suring installation",
|
|
"Errors occured during installation of %s failed" % pkg.name,
|
|
"Pacman failed to install %s" %pkg.name,
|
|
" ".join(process_stdout_lst),
|
|
"error",
|
|
True,
|
|
)
|
|
message_dialog.show_all()
|
|
result = message_dialog.run()
|
|
message_dialog.destroy()
|
|
elif progress_dialog is None or progress_dialog.pkg_dialog_closed is True:
|
|
# DOCS: https://bbs.archlinux.org/viewtopic.php?id=48234
|
|
if (
|
|
"error: failed to init transaction (unable to lock database)\n" in process_stdout_lst
|
|
):
|
|
if progress_dialog is None:
|
|
logger.debug("Holding Package")
|
|
if self.display_package_progress is False:
|
|
inst_str = [
|
|
"pacman",
|
|
"-S",
|
|
pkg.name,
|
|
"--needed",
|
|
"--noconfirm",
|
|
]
|
|
self.pkg_holding_queue.put(
|
|
(
|
|
pkg,
|
|
action,
|
|
switch,
|
|
inst_str,
|
|
progress_dialog,
|
|
),
|
|
)
|
|
else:
|
|
logger.debug(" ".join(process_stdout_lst))
|
|
switch.set_sensitive(True)
|
|
switch.set_state(False)
|
|
switch.set_active(False)
|
|
proc = fn.get_pacman_process()
|
|
message_dialog = MessageDialog(
|
|
"Warning",
|
|
"Unable to proceed, pacman lock found!",
|
|
"Pacman is unable to lock the database inside: %s" % fn.pacman_lockfile,
|
|
"Pacman is processing: %s" % proc,
|
|
"warning",
|
|
False,
|
|
)
|
|
message_dialog.show_all()
|
|
result = message_dialog.run()
|
|
message_dialog.destroy()
|
|
elif "error: traget not found: %s\n" %pkg.name in process_stdout_lst:
|
|
switch.set_sensitive(True)
|
|
switch.set_state(False)
|
|
switch.set_active(False)
|
|
message_dialog = MessageDialog(
|
|
"Error",
|
|
"%s not found!" % pkg.name,
|
|
"Blackbox unable to process the request!",
|
|
"Are you sure pacman config is correct?",
|
|
"error",
|
|
False,
|
|
)
|
|
message_dialog.show_all()
|
|
result = message_dialog.run()
|
|
message_dialog.destroy()
|
|
else:
|
|
switch.set_sensitive(True)
|
|
switch.set_state(False)
|
|
switch.set_active(False)
|
|
message_dialog = MessageDialog(
|
|
"Errors occured",
|
|
"Errors occured during installation of %s failed" % pkg.name,
|
|
"Pacman failed to install %s\n" %pkg.name,
|
|
" ".join(process_stdout_lst),
|
|
"error",
|
|
True,
|
|
)
|
|
message_dialog.show_all()
|
|
result = message_dialog.run()
|
|
message_dialog.destroy()
|
|
if installed is False and action =="uninstall":
|
|
logger.debug("Toggle switch state = False")
|
|
switch.set_sensitive(True)
|
|
switch.set_state(True)
|
|
switch.set_active(True)
|
|
if progress_dialog is not None:
|
|
if progress_dialog.pkg_dialog_closed is False:
|
|
progress_dialog.set_title(
|
|
"%s uninstalled!" %pkg.name
|
|
)
|
|
progress_dialog.infobar.set_name("infobar_info")
|
|
content =progress_dialog.infobar.get_content_area()
|
|
if content is not None:
|
|
for widget in content.get_children():
|
|
content.remove(widget)
|
|
lbl_install = Gtk.Label(xalign=0, yalign=0)
|
|
# DOCS: https://stackoverflow.com/questions/40072104/multi-color-text-in-one-gtk-label
|
|
lbl_install.set_markup(
|
|
"<b>Package %s installed.</b>" % pkg.name
|
|
)
|
|
content.add(lbl_install)
|
|
if self.timeout_id is not None:
|
|
# DOCS: https://gtk-rs.org/gtk-rs-core/stable/0.14/docs/glib/source/fn.source_remove.html
|
|
GLib.source_remove(self.timeout_id)
|
|
self.timeout_id = None
|
|
self.timeout_id = GLib.timeout_add(
|
|
100,
|
|
reveal_infobar,
|
|
self,
|
|
progress_dialog,
|
|
)
|
|
if installed is True and action == "uninstall":
|
|
# logger.debug("Toggle switch state = False")
|
|
switch.set_sensitive(True)
|
|
switch.set_state(True)
|
|
switch.set_active(True)
|
|
if progress_dialog is not None:
|
|
if progress_dialog.pkg_dialog_closed is False:
|
|
progress_dialog.set_title(
|
|
"Failed to uninstall %s !" %pkg.name
|
|
)
|
|
progress_dialog.infobar.set_name("infobar_error")
|
|
content =progress_dialog.infobar.get_content_area()
|
|
if content is not None:
|
|
for widget in content.get_children():
|
|
content.remove(widget)
|
|
lbl_install = Gtk.Label(xalign=0, yalign=0)
|
|
# DOCS: https://stackoverflow.com/questions/40072104/multi-color-text-in-one-gtk-label
|
|
lbl_install.set_markup(
|
|
"<b>Package %s uninstallation failed!</b>" % pkg.name
|
|
)
|
|
content.add(lbl_install)
|
|
if self.timeout_id is not None:
|
|
# DOCS: https://gtk-rs.org/gtk-rs-core/stable/0.14/docs/glib/source/fn.source_remove.html
|
|
GLib.source_remove(self.timeout_id)
|
|
self.timeout_id = None
|
|
self.timeout_id = GLib.timeout_add(
|
|
100,
|
|
reveal_infobar,
|
|
self,
|
|
progress_dialog,
|
|
)
|
|
elif progress_dialog is None or progress_dialog.pkg_dialog_closed is True:
|
|
if (
|
|
"error: failed to init transaction (unable to lock database)\n" in process_stdout_lst
|
|
):
|
|
logger.error(" ".join(process_stdout_lst))
|
|
else:
|
|
message_dialog = MessageDialog(
|
|
"Errors occured during uninstall",
|
|
"Errors occured during uninstallation of %s failed" % pkg.name,
|
|
"Pacman failed to uninstall %s\n" %pkg.name,
|
|
" ".join(process_stdout_lst),
|
|
"error",
|
|
True,
|
|
)
|
|
message_dialog.show_all()
|
|
result = message_dialog.run()
|
|
message_dialog.destroy()
|
|
|
|
|
|
def reveal_infobar(
|
|
self,
|
|
progress_dialog,
|
|
):
|
|
progress_dialog.infobar.set_revealed(True)
|
|
progress_dialog.infobar.show_all()
|
|
GLib.source_remove(self.timeout_id)
|
|
self.timeout_id = None
|
|
|
|
def update_progress_textview(
|
|
self,
|
|
line,
|
|
progress_dialog
|
|
):
|
|
if (
|
|
progress_dialog is not None
|
|
and progress_dialog.pkg_dialog_closed is False
|
|
and self.in_progress is True
|
|
):
|
|
buffer = progress_dialog.package_progress_textview.get_buffer()
|
|
# Docs: https://docs.python.org/3/library/asyncio-protocol.html#buffered-streaming-protocols
|
|
if len(line) > 0 or buffer is None:
|
|
buffer.insert(buffer.get_end_iter(), "%s" % line, len("%s" % line))
|
|
text_mark_end = buffer.create_mark("\nend", buffer.get_end_iter(), False)
|
|
# DOCS: https://lazka.github.io/pgi-docs/#Gtk-4.0/classes/TextView.html#Gtk.TextView.scroll_mark_onscreen
|
|
progress_dialog.package_progress_textview.scroll_mark_onscreen(
|
|
text_mark_end
|
|
)
|
|
else:
|
|
line = None
|
|
return False
|
|
|
|
|
|
def check_package_installed(package_name):
|
|
query_str = [
|
|
"pacman",
|
|
"-Qq",
|
|
]
|
|
try:
|
|
process_pkg_installed = subprocess.run(
|
|
query_str,
|
|
shell=False,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
universal_newlines=True,
|
|
)
|
|
if package_name in process_pkg_installed.stdout.splitlines():
|
|
return True
|
|
else:
|
|
if check_pacman_localdb(package_name):
|
|
return True
|
|
else:
|
|
return False
|
|
except subprocess.CalledProcessError:
|
|
return False # NOTE : It means package is not installed.
|
|
|
|
def check_pacman_localdb(package_name):
|
|
query_str = [
|
|
"pacman",
|
|
"-Qi",
|
|
package_name,
|
|
]
|
|
try:
|
|
process_pkg_installed = subprocess.run(
|
|
query_str,
|
|
shell=False,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
timeout=process_timeout,
|
|
)
|
|
if process_pkg_installed.returncode == 0:
|
|
for line in process_pkg_installed.stdout.decode("UTF-8").splitlines():
|
|
if line.startswith("Name :"):
|
|
if line.replace(" ", "").split("Name:")[1].strip() == package_name:
|
|
return True
|
|
if line.startswith("Replaces :"):
|
|
replaces = line.split("Replaces :")[1].strip()
|
|
if len(replaces) > 0:
|
|
if package_name in replaces:
|
|
return True
|
|
else:
|
|
return False
|
|
except subprocess.CalledProcessError:
|
|
return False # LOC: 387
|
|
|
|
# NOTE: App installation
|
|
def install(self):
|
|
pkg, action, widget, inst_str, progress_dialog = self.pkg_queue.get()
|
|
try:
|
|
if action == "install":
|
|
logger.debug(
|
|
"Running inside install thread"
|
|
)
|
|
logger.info(
|
|
"Installing: %s" % pkg.name
|
|
)
|
|
logger.debug(
|
|
inst_str,
|
|
)
|
|
th_subprocess_install = Thread(
|
|
name = "thread_subprocess",
|
|
target=start_subprocess,
|
|
args=(
|
|
self,
|
|
inst_str,
|
|
progress_dialog,
|
|
action,
|
|
pkg,
|
|
widget,
|
|
),
|
|
daemon=True
|
|
)
|
|
th_subprocess_install.start()
|
|
logger.debug(
|
|
"Thread: subprocess install started!"
|
|
)
|
|
except Exception as e:
|
|
widget.set_state(False)
|
|
if progress_dialog is not None:
|
|
progress_dialog.btn_package_progress_close.set_sensitive(True)
|
|
finally:
|
|
self.pkg_queue.task_done()
|
|
|
|
# NOTE: App uninstall
|
|
def uninstall(self):
|
|
pkg, action, widget, uninst_str, progress_dialog = self.pkg_queue.get()
|
|
try:
|
|
if action == "uninstall":
|
|
logger.debug(
|
|
"Running inside uninstall thread"
|
|
)
|
|
logger.info(
|
|
"Uninstalling: %s" % pkg.name
|
|
)
|
|
logger.debug(
|
|
uninst_str,
|
|
)
|
|
th_subprocess_install = Thread(
|
|
name = "thread_subprocess",
|
|
target=start_subprocess,
|
|
args=(
|
|
self,
|
|
uninst_str,
|
|
progress_dialog,
|
|
action,
|
|
pkg,
|
|
widget,
|
|
),
|
|
daemon=True
|
|
)
|
|
th_subprocess_install.start()
|
|
logger.debug(
|
|
"Thread: subprocess uninstall started!"
|
|
)
|
|
except Exception as e:
|
|
widget.set_state(True)
|
|
if progress_dialog is not None:
|
|
progress_dialog.btn_package_progress_close.set_sensitive(True)
|
|
finally:
|
|
self.pkg_queue.task_done()
|
|
|
|
def store_packages():
|
|
path = base_dir + "/yaml/"
|
|
cache = base_dir + "/cache/yaml-packages.lst"
|
|
yaml_files = []
|
|
packages = []
|
|
category_dict = {}
|
|
try:
|
|
package_metadata = get_all_package_info()
|
|
for file in os.listdir(path):
|
|
if file.endswith(".yaml"):
|
|
yaml_files.append(file)
|
|
|
|
if len(yaml_files) > 0:
|
|
for yaml_file in yaml_files:
|
|
cat_desc = ""
|
|
package_name = ""
|
|
package_cat = ""
|
|
category_name = yaml_file[11:-5].strip().capitalize()
|
|
with open(path + yaml_file, "r") as yaml:
|
|
content = yaml.readlines()
|
|
for line in content:
|
|
if line.startswith(" packages:"):
|
|
continue
|
|
elif line.startswith(" description: "):
|
|
subcat_desc = (
|
|
line.strip(" description: ")
|
|
.strip()
|
|
.strip('"')
|
|
.strip("\n")
|
|
.strip()
|
|
)
|
|
elif line.startswith("- name:"):
|
|
subcat_name = (
|
|
line.strip("- name:")
|
|
.strip()
|
|
.strip('"')
|
|
.strip("\n")
|
|
.strip()
|
|
)
|
|
elif line.startswith(" - "):
|
|
package_name = line.strip(" - ").strip()
|
|
package_version = "Unknown"
|
|
package_description = "Unknown"
|
|
for data in package_metadata:
|
|
if data["name"] == package_name:
|
|
package_version = data["version"]
|
|
package_description = data["description"]
|
|
break
|
|
if package_description == "Unknown":
|
|
package_description = obtain_pkg_description(package_name)
|
|
package = Package(
|
|
package_name,
|
|
package_description,
|
|
category_name,
|
|
subcat_name,
|
|
subcat_desc,
|
|
package_version,
|
|
)
|
|
packages.append(package)
|
|
|
|
category_name = None
|
|
packages_cat_lst = []
|
|
for pkg in packages:
|
|
if category_name == pkg.category:
|
|
packages_cat_lst.append(pkg)
|
|
category_dict[category_name] = packages_cat_lst
|
|
elif category_name is None:
|
|
packages_cat_lst.append(pkg)
|
|
category_dict[pkg.category] = packages_cat_lst
|
|
else:
|
|
packages_cat_lst = []
|
|
packages_cat_lst.append(pkg)
|
|
category_dict[pkg.category] = packages_cat_lst
|
|
category_name = pkg.category
|
|
sorted_dict = None
|
|
sorted_dict = dict(sorted(category_dict.items()))
|
|
if sorted_dict is None:
|
|
logger.error(
|
|
"An error occurred during sort of packages in stored_packages()"
|
|
)
|
|
else:
|
|
with open(cache, "w", encoding="UTF-8") as f:
|
|
for key in category_dict.keys():
|
|
pkg_list = category_dict[key]
|
|
for pkg in pkg_list:
|
|
f.write("%s\n" % pkg.name)
|
|
return sorted_dict
|
|
except Exception as e:
|
|
logger.error(
|
|
"Exception found: %s" % e
|
|
)
|
|
sys.exit(1)
|
|
|
|
def get_all_package_info():
|
|
query_str = [
|
|
"pacman",
|
|
"-Si",
|
|
]
|
|
try:
|
|
process_pkg_query = subprocess.Popen(
|
|
query_str,
|
|
shell=False,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
)
|
|
out, err = process_pkg_query.communicate(timeout=process_timeout)
|
|
if process_pkg_query.returncode == 0:
|
|
if out:
|
|
package_data = []
|
|
package_name = "Unknown"
|
|
package_version = "Unknown"
|
|
package_description = "Unknown"
|
|
package_repository = "Unknown"
|
|
for line in out.decode("UTF-8").splitlines():
|
|
package_dict = {}
|
|
|