def run(cmdargs):
"""
Run and monitor a command
Args:
cmdargs (list of string): command and args to run
Returns:
error code (integer)
"""
os.environ["MONITOR_PID"] = str(os.getpid())
subproc = subprocess.Popen(cmdargs, shell=False)
if not monitor(subproc, MONITOR_TIMEOUT):
return subproc.returncode
kano_updater.utils.track_data_and_sync('updater-hanged-indefinitely',
dict())
if '--keep-uuid' not in cmdargs:
kano_updater.utils.clear_tracking_uuid()
if '--gui' in cmdargs:
from kano.gtk3 import kano_dialog
kdialog = kano_dialog.KanoDialog(
_("Update error"),
_("The updater seems to have got stuck. Press OK to reboot"))
kdialog.run()
os.system('systemctl reboot')
# for test purposes:
time.sleep(10)
os._exit(kano_updater.return_codes.RC.HANGED_INDEFINITELY)
return kano_updater.return_codes.RC.HANGED_INDEFINITELY
def show_reboot_dialog():
rd_title = _("Update successful!")
rd_desc = _("Now we just need to do a quick reboot. See you in a minute!")
reboot_dialog = kano_dialog.KanoDialog(rd_title, rd_desc)
reboot_dialog.run()
while Gtk.events_pending():
Gtk.main_iteration()
def remove_account_dialog(self, widget=None, event=None):
if not hasattr(event, 'keyval') or event.keyval == Gdk.KEY_Return:
# Bring in message dialog box
kdialog = kano_dialog.KanoDialog(
_("Are you sure you want to delete the current user?"),
_("You will lose all the data on this account!"),
[{
'label': _("CANCEL"),
'color': 'red',
'return_value': False
}, {
'label': _("OK"),
'color': 'green',
'return_value': True
}],
parent_window=self.win)
do_delete_user = kdialog.run()
if do_delete_user:
self.disable_buttons()
try:
delete_user()
except UserError as e:
kdialog = kano_dialog.KanoDialog(_("Error deleting user"),
str(e),
parent_window=self.win)
return
kdialog = kano_dialog.KanoDialog(
_("To finish removing this account, you need to reboot"),
_("Do you want to reboot?"), [{
'label': _("LATER"),
'color': 'grey',
'return_value': False
}, {
'label': _("REBOOT NOW"),
'color': 'orange',
'return_value': True
}],
parent_window=self.win)
do_reboot_now = kdialog.run()
if do_reboot_now:
os.system("sudo systemctl reboot")
def update_failed(err):
from kano.gtk3 import kano_dialog
logger.error("Update failed: {}".format(err))
msg = _("We had a problem with the Update. "
"Make sure you are connected to the Internet, and give it another go.\n\n"
"If you still have problems, we can help at http://help.kano.me")
kdialog = kano_dialog.KanoDialog(_("Update error"), msg)
kdialog.run()
def add_account(self, widget=None, event=None):
if not hasattr(event, 'keyval') or event.keyval == Gdk.KEY_Return:
kdialog = None
try:
# add new user command
add_user()
except UserError as e:
kdialog = kano_dialog.KanoDialog(_("Error creating new user"),
str(e),
parent_window=self.win)
else:
kdialog = kano_dialog.KanoDialog(
_("Reboot the system"),
_("A new account will be created next time you reboot."),
parent_window=self.win)
# Tell user to reboot to see changes
common.need_reboot = True
kdialog.run()
self.disable_buttons()
def add_account_dialog(self):
kdialog = kano_dialog.KanoDialog(
_("Add an Account"),
_("To add an account, you need to reboot. If you have any files open, you should cancel and save your files first. Add and reboot now?"
), [{
"label": _("REBOOT NOW"),
"return_value": True,
"color": "orange"
}, {
"label": _("CANCEL"),
"return_value": False,
"color": "green"
}])
return kdialog.run()
def root_check():
from kano.gtk3 import kano_dialog
user = os.environ['LOGNAME']
if user != 'root':
description = 'kano-updater must be executed with root privileges'
logger.error(description)
if is_gui():
kdialog = kano_dialog.KanoDialog(
_("Error!"),
_("kano-updater must be executed with root privileges")
)
kdialog.run()
sys.exit(description)
def create_error_dialog(
message1=_("Could not change password"), message2="", win=None):
kdialog = kano_dialog.KanoDialog(message1,
message2, [{
'label': _("GO BACK"),
'color': 'red',
'return_value': False
}, {
'label': _("TRY AGAIN"),
'color': 'green',
'return_value': True
}],
parent_window=win)
response = kdialog.run()
return response
def add_account(self, widget=None, event=None):
if not hasattr(event, 'keyval') or event.keyval == Gdk.KEY_Return:
kdialog = None
if not self.add_account_dialog():
return
try:
# add new user command
add_user()
except UserError as e:
kdialog = kano_dialog.KanoDialog(_("Error creating new user"),
str(e),
parent_window=self.win)
kdialog.run()
self.disable_buttons()
else:
os.system("sudo systemctl reboot")
def run(cmdargs):
"""
Run and monitor a command
Args:
cmdargs (list of string): command and args to run
Returns:
error code (integer)
"""
if 'MONITOR_PID' in os.environ:
os.execvp(cmdargs[0], cmdargs)
os.environ["MONITOR_PID"] = str(os.getpid())
subproc = subprocess.Popen(cmdargs, shell=False)
if not monitor(subproc, MONITOR_TIMEOUT):
return subproc.returncode
logger.error(
'Updater monitor timeout: The monitored process ({}) did not respond for {} seconds'
.format(cmdargs, MONITOR_TIMEOUT))
track_data_and_sync('updater-hanged-indefinitely', dict())
send_crash_report(
'Updater monitor timeout',
'The monitored process ({}) did not respond for {} seconds'.format(
cmdargs, MONITOR_TIMEOUT))
if '--keep-uuid' not in cmdargs:
clear_tracking_uuid()
if '--gui' in cmdargs:
from kano.gtk3 import kano_dialog
kdialog = kano_dialog.KanoDialog(
_("Update error"),
_("The updater seems to have got stuck. Press OK to reboot"))
kdialog.run()
os.system('systemctl reboot')
# for test purposes:
time.sleep(10)
os._exit(RC.HANGED_INDEFINITELY)
return RC.HANGED_INDEFINITELY
def show_results(msg_upgraded, msg_added, msg_removed, debian_err_packages,
appstate_after_nonclean, python_ok, python_err):
# Create Gtk textiew with markdown
text_view = Gtk.TextView()
text_view.set_margin_top(10)
text_view.set_margin_bottom(20)
text_view.set_margin_left(20)
text_view.set_margin_right(20)
text_buffer = text_view.get_buffer()
bold_tag = text_buffer.create_tag('bold', weight=Pango.Weight.BOLD)
scrolled_window = ScrolledWindow()
scrolled_window.apply_styling_to_widget()
scrolled_window.add_with_viewport(text_view)
scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scrolled_window.set_size_request(400, 200)
result_dialog = kano_dialog.KanoDialog(_("Update result"),
"",
widget=scrolled_window,
global_style=True)
result_dialog.dialog.set_icon_name('kano-updater')
result_dialog.dialog.set_title(_("Kano Updater"))
if msg_upgraded:
text = _("\nApps upgraded:\n")
add_text_to_end(text_buffer, text, bold_tag)
add_text_to_end(text_buffer, msg_upgraded)
if msg_added:
text = _("\nApps added:\n")
add_text_to_end(text_buffer, text, bold_tag)
add_text_to_end(text_buffer, msg_added)
if msg_removed:
text = _("\nApps removed:\n")
add_text_to_end(text_buffer, text, bold_tag)
add_text_to_end(text_buffer, msg_removed)
if debian_err_packages:
text = _("\nApps with errors:\n")
add_text_to_end(text_buffer, text, bold_tag)
msg_error = "{}\n".format('\n'.join(debian_err_packages))
add_text_to_end(text_buffer, msg_error)
if appstate_after_nonclean:
text = _("\nApps with non-clean state:\n")
add_text_to_end(text_buffer, text, bold_tag)
non_clean_list = '\n'.join(appstate_after_nonclean.iterkeys())
msg_non_clean_list = non_clean_list + "\n"
add_text_to_end(text_buffer, msg_non_clean_list)
if python_ok:
text = _("\nPython modules upgraded:\n")
add_text_to_end(text_buffer, text, bold_tag)
python_modules = "{}\n".format('\n'.join(python_ok))
add_text_to_end(text_buffer, python_modules)
if python_err:
text = _("\nPython modules with error:\n")
add_text_to_end(text_buffer, text, bold_tag)
err_list = '\n'.join(python_err)
msg_python_err = err_list + "\n"
add_text_to_end(text_buffer, msg_python_err)
if not (msg_upgraded or msg_added or msg_removed or debian_err_packages
or appstate_after_nonclean or python_ok or python_err):
add_text_to_end(text_buffer, _("No updates needed this time."),
bold_tag)
result_dialog.run()
while Gtk.events_pending():
Gtk.main_iteration()
def reboot(title, description):
from kano.gtk3 import kano_dialog
kdialog = kano_dialog.KanoDialog(title, description)
kdialog.run()
run_cmd('systemctl reboot')
def create_success_dialog(message1, message2, win):
kdialog = kano_dialog.KanoDialog(message1, message2, parent_window=win)
response = kdialog.run()
return response