Context Navigation

source: first-aid-kit/trunk/fuentes/first-aid-kit.install/usr/share/first-aid-kit/KernelBox.py @ 8614

Last change on this file since 8614 was 8614, checked in by daduve, 2 years ago
Apply update-grub2 when you change kernel by defect
File size: 27.0 KB

Line
1	import gi
2	gi.require_version('Gtk', '3.0')
3	from gi.repository import Gtk, Pango, GdkPixbuf, Gdk, Gio, GObject,GLib
4
5	import copy
6	import gettext
7	import Core
8
9	import Dialog
10	import time
11	import threading
12	import sys
13	import os
14	import subprocess
15	import apt
16	import platform
17	import copy
18	import shutil
19
20	gettext.textdomain('first-aid-kit-gui')
21	_=gettext.gettext
22
23
24	RSRC="./rsrc/"
25
26
27	class KernelBox(Gtk.VBox):
28
29
30	def __init__(self):
31
32	try:
33	Gtk.VBox.__init__(self)
34
35	self.core=Core.Core.get_core()
36
37	builder=Gtk.Builder()
38	builder.set_translation_domain('first-aid-kit-gui')
39	ui_path=RSRC + "first-aid-kit.ui"
40	builder.add_from_file(ui_path)
41
42
43	self.kernel_box=builder.get_object("kernel_box")
44	self.kernel_label=builder.get_object("kernel_label")
45	self.kernel_vp=builder.get_object("viewport3")
46	self.kernel_sw=builder.get_object("scrolledwindow4")
47	self.info_box_kernel=builder.get_object("info_kernel")
48	self.txt_check_kernel=builder.get_object("txt_check_kernel")
49	self.spinner_info_kernel=builder.get_object("spinner_info_kernel")
50	self.separator_kernel=builder.get_object("separator3")
51	self.kernel_list_box=builder.get_object("box16")
52	self.entry_kernel=builder.get_object("entry_kernel")
53	self.update_kernels_button=builder.get_object("kernel_update_button")
54	self.filter_kernels_button=builder.get_object("kernel_filter_button")
55	self.apply_kernel_button=builder.get_object("apply_kernel_button")
56	self.kernel_combobox=builder.get_object("kernel_combobox")
57	self.kernel_combobox_spinner=builder.get_object("kernel_combobox_spinner")
58	self.switch_kernel_installed=builder.get_object("switch_kernel_installed")
59	self.kernel_installed_spinner=builder.get_object("kernel_installed_spinner")
60
61
62	self.add(self.kernel_box)
63
64
65
66
67	self.info_box_stack=Gtk.Stack()
68	self.info_box_stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
69	self.info_box_stack.set_transition_duration(500)
70	hbox_kernel=Gtk.HBox()
71	hbox_kernel.show()
72	self.info_box_stack.add_titled(hbox_kernel,"empty_box_kernel","Empty Box Kernel")
73	self.info_box_stack.add_titled(self.info_box_kernel,"info_kernel","InfoBoxKernel")
74
75	self.wawabox3=Gtk.HBox()
76	self.wawabox3.pack_start(self.info_box_stack,True,True,0)
77
78	self.kernel_box.pack_start(self.wawabox3,False,False,5)
79
80
81	self.info_box_kernel.set_margin_bottom(20)
82	self.info_box_kernel.set_margin_left(5)
83	self.info_box_kernel.set_margin_right(5)
84
85	self.info_box_stack.set_visible_child_name("empty_box_kernel")
86
87
88	self.kernel_box_stack=Gtk.Stack()
89	self.kernel_box_stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
90	self.kernel_box_stack.set_transition_duration(500)
91	load_spinner=Gtk.Spinner()
92	load_spinner.show()
93	load_spinner.start()
94	self.kernel_box_stack.add_titled(load_spinner,"spinner","")
95	self.kernel_box_stack.add_titled(self.kernel_list_box,"kernels","")
96
97	self.kernel_vp.add(self.kernel_box_stack)
98
99	self.kernel_filter=''
100
101	self.flag_installed=False
102	self.kernel_combobox_spinner_active=False
103
104	self.kernel_installed_filter_active=False
105	self.switch_kernel_installed.set_state(False)
106	self.switch_kernel_installed.set_sensitive(False)
107
108	self.init_kernel_boot_store()
109	self.connect_signals()
110	self.set_css_info()
111	self.load_kernels()
112
113
114
115	except Exception as e:
116	self.core.dprint("(KernelBox)Error: %s"%e)
117
118	#def __init__
119
120
121
122
123
124
125
126
127
128	def set_css_info(self):
129
130
131	self.style_provider=Gtk.CssProvider()
132	f=Gio.File.new_for_path("first-aid-kit.css")
133	self.style_provider.load_from_file(f)
134	Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
135
136	self.info_box_kernel.set_name("PKG_BOX")
137	self.separator_kernel.set_name("SEPARATOR")
138
139	self.kernel_list_box.set_name("PKG_BOX")
140
141	self.kernel_label.set_name("SECTION_LABEL")
142
143	self.txt_check_kernel.set_name("INFO_LABEL")
144
145	self.update_kernels_button.set_name("EXECUTE_BUTTON")
146	self.filter_kernels_button.set_name("EXECUTE_BUTTON")
147	self.apply_kernel_button.set_name("EXECUTE_BUTTON")
148
149	#def set-css_info
150
151
152
153
154
155
156
157
158	def connect_signals(self):
159
160
161	self.update_kernels_button.connect("clicked",self.update_kernels_button_clicked)
162	self.apply_kernel_button.connect("clicked",self.set_kernel_default)
163	self.filter_kernels_button.connect("clicked",self.filter_kernels_button_clicked)
164	self.entry_kernel.connect("activate",self.entries_press_event)
165	self.switch_kernel_installed.connect("notify::active",self.kernel_installed_filter)
166
167	#def connect_signals
168
169
170
171	def entries_press_event(self,widget):
172
173	self.filter_kernels_button_clicked(None)
174
175	#def entries_press_event
176
177
178
179
180
181
182	def init_kernel_boot_store(self):
183
184	#PRINT KERNEL COMBOBOX
185
186	#self.core.dprint("Combobox Kernel: %s"%self.kernel_installed_boot)
187	renderer=Gtk.CellRendererText()
188	self.kernel_combobox.pack_start(renderer,True)
189	self.kernel_combobox.add_attribute(renderer,"text",0)
190	self.kernel_installed_boot=Gtk.ListStore(str)
191	self.kernel_combobox.set_model(self.kernel_installed_boot)
192	self.kernel_combobox.set_active(0)
193
194	#def kernel_boot
195
196
197
198	def read_kernel_default(self):
199	# SET IN COMBOBOX WICH KERNEL IS ACTIVE AT THE MOMENT.
200	try:
201	#GRUB DEFAULT EXISTS? DEFINE POSITION, BUT NOT WICH KERNEL NUMBER
202	grub_file='/etc/default/grub'
203	f_orig=open(grub_file)
204	lines=f_orig.readlines()
205	f_orig.close()
206	line_writed=False
207
208	for line in lines:
209	if "GRUB_DEFAULT=" in line:
210	kernel_default_pos=line.replace('GRUB_DEFAULT=','')
211	kernel_default_pos=kernel_default_pos.split()[0]
212	break
213	else:
214	kernel_default_pos="0>0"
215
216
217	######### ESTO FUNCIONA DE LUJO NO TOCAR ACUERDATE QUE POSEES COSAS ANULADAS ABAJO Y QUE LA GUI DE GLADE NO ESTA ORGANIZANDOME EL BOX COMO QUIERO
218	#CHECK WICH KERNEL NUMBER IS ACTIVE, IF POSITION IS DEFINED IN GRUB DEFAUTL OR 0>0 BY DEFAULT.
219	kernel_file="/tmp/.first-aid-kit_set-kernel.%s"%self.core.current_user
220	os.system('/usr/share/first-aid-kit/grub-listmenu.sh > %s'%kernel_file)
221	f=open(kernel_file)
222	lines=f.readlines()
223	f.close()
224	os.remove(kernel_file)
225
226	finded=False
227	for line in lines:
228	if kernel_default_pos in line:
229	line=line.replace(kernel_default_pos,'')
230	if "-generic" in line:
231	line=line.replace('-generic','')
232	if "LliureX 16" in line:
233	line=line.replace('LliureX 16','')
234
235	newstr = ''.join((ch if ch in '0123456789.-' else ' ') for ch in line)
236	kernel_active = [str(i) for i in newstr.split()]
237	finded=True
238	break
239
240	#SELECT KERNEL ACTIVE IN COMBOBOX
241	pos=0
242	if finded:
243	for k in kernel_active:
244	for i in self.kernel_installed_boot:
245	element=(i[:])[0]
246	#print ('%s element: %s'%(pos,element))
247	if str(k)==str(element):
248	#print 'eureka'
249	return pos
250	pos+=1
251
252	#print pos
253	#print 'SALIDA'
254	return pos
255
256
257	except Exception as e:
258	return 0
259	self.core.dprint("(read_kernel_default) Error: %s"%e)
260	#def read_kernel_default
261
262
263
264
265	def set_kernel_default(self,widget):
266	#SET KERNEL DEFAULT IN COMBOBOX
267	try:
268	it=self.kernel_combobox.get_active_iter()
269	self.kernel_selected=self.kernel_installed_boot.get(it,0)[0]
270	#self.kernel_po=self.eth_wharehouse[eth_selected]
271	self.core.dprint("(set_kernel_default)Kernel default selected: %s "%(self.kernel_selected))
272
273	kernel_file="/tmp/.first-aid-kit_set-kernel.%s"%self.core.current_user
274	os.system('/usr/share/first-aid-kit/grub-listmenu.sh > %s'%kernel_file)
275	f=open(kernel_file)
276	lines=f.readlines()
277	f.close()
278	os.remove(kernel_file)
279
280
281	for line in lines:
282	if self.kernel_selected in line:
283	if not "recovery" in line:
284	default_grub_option=line.split()[0]
285
286	self.core.dprint("(set_kernel_default)Kernel defautl position in Grub: %s"%(default_grub_option))
287
288	grub_file='/etc/default/grub'
289	f_orig=open(grub_file)
290	lines=f_orig.readlines()
291	f_orig.close()
292
293	grub_file_tmp='/tmp/.grub'
294	f_copy=open(grub_file_tmp,"wt")
295
296	line_writed=False
297	for line in lines:
298	if "GRUB_DEFAULT=" in line:
299	f_copy.write("GRUB_DEFAULT=%s\n"%default_grub_option)
300	line_writed=True
301	else:
302	f_copy.write(line)
303
304	if not line_writed:
305	f_copy.write("GRUB_DEFAULT=%s\n"%default_grub_option)
306	f_copy.close()
307
308	shutil.copy(grub_file_tmp,grub_file)
309
310	self.switch_kernel_installed.set_sensitive(False)
311	self.update_kernels_button.set_sensitive(False)
312	self.filter_kernels_button.set_sensitive(False)
313	self.apply_kernel_button.set_sensitive(False)
314	self.entry_kernel.set_can_focus(False)
315	self.kernel_box_stack.set_visible_child_name("spinner")
316
317	allocation=self.kernel_combobox.get_allocation()
318	w=allocation.width
319	h=allocation.height
320
321	self.kernel_combobox.hide()
322	self.kernel_combobox_spinner.start()
323	self.kernel_combobox_spinner.set_size_request(w,h)
324	self.kernel_combobox_spinner.show()
325	self.kernel_combobox_spinner_active=True
326
327	self.thread_install=threading.Thread(target=self.set_kernel_default_thread)
328	self.thread_install.daemon=True
329	self.thread_install.start()
330
331	GLib.timeout_add(500,self.check_set_kernel_default_thread)
332
333	except Exception as e:
334	self.core.dprint("(set_kernel_default) Error: %s"%e)
335
336	#def set_kernel_default
337
338
339
340	def set_kernel_default_thread(self):
341
342	try:
343	self.core.working=True
344	proc=subprocess.Popen('update-grub2',shell=True, stdin=None, stdout=open("/dev/null","w"), stderr=None, executable="/bin/bash")
345	proc.wait()
346	except Exception as e:
347	self.core.dprint("(kernel_install_thread) Error: %s"%e)
348
349	#def kernel_install_thread
350
351
352
353	def check_set_kernel_default_thread(self):
354
355	try:
356	if self.thread_install.is_alive():
357	return True
358
359	self.flag_installed=True
360	self.read_kernel_default()
361	self.core.working=False
362
363	self.kernel_box_stack.set_visible_child_name("kernels")
364	self.update_kernels_button.set_sensitive(True)
365	self.filter_kernels_button.set_sensitive(True)
366	self.apply_kernel_button.set_sensitive(True)
367	self.entry_kernel.set_can_focus(True)
368
369	self.kernel_installed_spinner.hide()
370
371
372	self.switch_kernel_installed.show()
373	self.switch_kernel_installed.set_sensitive(True)
374
375	self.kernel_combobox.set_active(self.read_kernel_default())
376	self.kernel_combobox.show()
377	self.kernel_combobox_spinner.hide()
378	self.kernel_combobox_spinner_active=False
379
380	self.info_box_stack.set_visible_child_name("info_kernel")
381	self.txt_check_kernel.set_text(_("You have a new kernel boot by defect: %s"%self.kernel_selected))
382	self.core.dprint("You have a new kernel boot by defect: %s"%self.kernel_selected)
383
384	except Exception as e:
385	self.core.dprint("(check_set_kernel_default_thread) Error: %s"%e)
386
387	#def check_kernel_install_thread
388
389
390
391
392
393
394
395	def kernel_installed_filter(self,widget,params):
396
397	try:
398	if self.switch_kernel_installed.get_active():
399	self.kernel_installed_filter_active=True
400	else:
401	self.kernel_installed_filter_active=False
402
403	self.switch_kernel_installed.set_sensitive(False)
404	self.update_kernels_button.set_sensitive(False)
405	self.filter_kernels_button.set_sensitive(False)
406	self.apply_kernel_button.set_sensitive(False)
407	self.entry_kernel.set_can_focus(False)
408	self.kernel_box_stack.set_visible_child_name("spinner")
409
410
411	allocation=self.switch_kernel_installed.get_allocation()
412	w=allocation.width
413	h=allocation.height
414
415	self.switch_kernel_installed.hide()
416	self.kernel_installed_spinner.start()
417	self.kernel_installed_spinner.set_size_request(w,h)
418	self.kernel_installed_spinner.show()
419
420	self.info_box_stack.set_visible_child_name("info_kernel")
421	self.txt_check_kernel.set_text(_("Applying filter to show only installed kernels...please wait"))
422	self.core.dprint("Applying filter to show only installed kernels...please wait")
423
424	self.show_kernel_results()
425
426	except Exception as e:
427	self.core.dprint("(kernel_installed_filter) Error: %s"%e)
428
429	#def kernel_installed_filter
430
431
432
433
434
435
436
437
438	def filter_kernels_button_clicked (self,widget):
439	try:
440	self.entry_kernel.set_can_focus(False)
441	self.kernel_filter=self.entry_kernel.get_text().split()
442	#print self.kernel_filter
443	self.update_kernels_button.set_sensitive(False)
444	self.filter_kernels_button.set_sensitive(False)
445	self.apply_kernel_button.set_sensitive(False)
446	self.switch_kernel_installed.set_sensitive(False)
447	self.kernel_box_stack.set_visible_child_name("spinner")
448
449	self.info_box_stack.set_visible_child_name("info_kernel")
450	self.txt_check_kernel.set_text(_("Applying filter to kernels...please wait"))
451	self.core.dprint("Applying filter to kernels...")
452	self.load_kernels()
453
454
455	except Exception as e:
456	self.core.dprint("(filter_kernels_button_clicked) Error: %s"%e)
457
458	#def filter_kernels_button_clicked
459
460
461
462
463
464
465
466	def update_kernels_button_clicked (self,widget):
467	try:
468
469	self.entry_kernel.set_can_focus(False)
470	self.kernel_filter=self.entry_kernel.get_text().split()
471	print self.kernel_filter
472	self.update_kernels_button.set_sensitive(False)
473	self.filter_kernels_button.set_sensitive(False)
474	self.apply_kernel_button.set_sensitive(False)
475	self.switch_kernel_installed.set_sensitive(False)
476
477	for i in self.kernel_list_box:
478	self.kernel_list_box.remove(i)
479
480	self.kernel_box_stack.set_visible_child_name("spinner")
481	self.kernel_box_stack.set_size_request(0,0)
482
483	allocation=self.kernel_combobox.get_allocation()
484	w=allocation.width
485	h=allocation.height
486
487	self.kernel_combobox.hide()
488	self.kernel_combobox_spinner.start()
489	self.kernel_combobox_spinner.set_size_request(w,h)
490	self.kernel_combobox_spinner.show()
491	self.kernel_combobox_spinner_active=True
492
493	self.info_box_stack.set_visible_child_name("info_kernel")
494	self.txt_check_kernel.set_text(_("Updating Kernel Cache...please wait"))
495	self.core.dprint("Updating Kernel Cache...")
496
497	self.thread_up=threading.Thread(target=self.update_kernels_thread)
498	self.thread_up.daemon=True
499	self.thread_up.start()
500
501	self.kernel_vp.set_size_request(0,0)
502	self.kernel_sw.get_vadjustment().set_page_size(0)
503	self.kernel_sw.get_hadjustment().set_page_size(0)
504	self.kernel_sw.set_size_request(0,0)
505	print("hola")
506
507	GLib.timeout_add(500,self.check_update_kernels_thread)
508
509	except Exception as e:
510	self.core.dprint("(update_kernels_button_clicked) Error: %s"%e)
511
512	#def update_kernels_button_clicked
513
514
515
516	def update_kernels_thread(self):
517
518	try:
519
520	self.cache.update()
521
522	except Exception as e:
523	self.core.dprint("(update_kernels_thread) Error: %s"%e)
524
525	#def update_kernels_thread
526
527
528
529	def check_update_kernels_thread(self):
530
531	try:
532	if self.thread_up.is_alive():
533	return True
534
535	self.load_kernels()
536
537	except Exception as e:
538	self.core.dprint("(check_update_kernels_thread) Error: %s"%e)
539
540	#def check_update_kernels_thread
541
542
543
544
545
546
547
548
549	def load_kernels(self):
550
551	try:
552	self.entry_kernel.set_can_focus(False)
553	self.update_kernels_button.set_sensitive(False)
554	self.filter_kernels_button.set_sensitive(False)
555	self.apply_kernel_button.set_sensitive(False)
556	self.switch_kernel_installed.set_sensitive(False)
557	self.switch_kernel_installed.set_sensitive(False)
558
559
560
561	self.read_kernels()
562
563	except Exception as e:
564	self.core.dprint("(load_kernels) Error: %s"%e)
565
566	#def load_kernels
567
568
569
570
571	def read_kernels(self):
572
573	try:
574	if self.kernel_combobox_spinner_active:
575
576	allocation=self.kernel_combobox.get_allocation()
577	w=allocation.width
578	h=allocation.height
579
580	self.kernel_combobox.hide()
581	self.kernel_combobox_spinner.start()
582	self.kernel_combobox_spinner.set_size_request(w,h)
583	self.kernel_combobox_spinner.show()
584
585	self.thread=threading.Thread(target=self.read_kernels_thread)
586	self.thread.daemon=True
587	self.thread.start()
588
589	self.core.dprint("Reading kernels avaiables..........")
590	self.kernel_installed_boot.clear()
591	GLib.timeout_add(500,self.check_read_kernels_thread)
592
593	except Exception as e:
594	self.core.dprint("(read_kernels) Error: %s"%e)
595
596	#def read_kernels
597
598
599
600	def read_kernels_thread(self):
601	try:
602
603	platform.architecture()[0]
604	if '64' in platform.architecture()[0]:
605	self.arch64=True
606	else:
607	self.arch64=False
608
609	self.cache=apt.cache.Cache()
610
611	pkgs=[pkg for pkg in self.cache]
612
613	self.avaiable=[]
614	self.installed=[]
615	self.kernel_count_orig=0
616
617	for i in pkgs:
618	if not 'linux-headers-generic' == str(i):
619	if 'linux-header' in str(i):
620	if 'generic' in str(i):
621	version=str(i)
622	linux_image=version.replace('linux-headers-','linux-image-')
623	version=version.replace('linux-headers-','')
624	version=version.replace('generic-','')
625	version=version.replace('-generic','')
626	if self.arch64:
627	if not 'i386' in str(i):
628	if self.cache[str(i)].is_installed:
629	self.installed.append(version)
630	self.avaiable.append((version,str(i),True,linux_image))
631
632	self.kernel_installed_boot.append([version])
633	self.kernel_count_orig=self.kernel_count_orig+1
634	#print ('%s is installed'%version)
635	else:
636
637	self.avaiable.append((version,str(i),False,linux_image))
638	#print i
639	else:
640	if 'i386' in str(i):
641	if self.cache[str(i)].is_installed:
642	self.installed.append(version)
643	self.avaiable.append((version,str(i),True,linux_image))
644	self.kernel_installed_boot.append([version])
645	self.kernel_count_orig=self.kernel_count_orig+1
646	#print ('%s is installed'%version)
647	else:
648	self.avaiable.append((version,str(i),False,linux_image))
649
650	#self.kernel_boot()
651	self.filtered=[]
652	if len(self.kernel_filter)>0:
653	#print 'In filter....'
654	for i in self.avaiable:
655	add=True
656	#print i
657	for option in self.kernel_filter:
658	#print 'Apply filter: %s'%option
659	if not str(option) in str(i[1]):
660	add=False
661	if add:
662	#print " Added "
663	self.filtered.append(i)
664
665	self.avaiable=self.filtered
666
667
668
669	#print self.avaiable
670
671	except Exception as e:
672	self.core.dprint("(read_kernels_thread) Error: %s"%e)
673
674	#def read_kernels
675
676
677	def check_read_kernels_thread(self):
678
679	try:
680	if self.thread.is_alive():
681	return True
682
683	self.show_kernel_results()
684
685	except Exception as e:
686	self.core.dprint("(check_read_kernels_thread) Error: %s"%e)
687
688	#def check_read_kernels_thread
689
690
691
692
693	def show_kernel_results(self):
694	try:
695
696	#count=len(self.avaiable)
697	count=0
698
699	for i in self.kernel_list_box:
700	self.kernel_list_box.remove(i)
701
702	for kernel in self.avaiable:
703
704	if self.kernel_installed_filter_active:
705	if kernel[2]:
706	count=count+1
707	self.generate_element_list(kernel)
708	else:
709	count=count+1
710	self.generate_element_list(kernel)
711
712	count-=1
713	if count>0:
714	s=Gtk.Separator()
715	s.show()
716	self.kernel_list_box.pack_start(s,False,False,5)
717	self.kernel_list_box.set_margin_bottom(20)
718	self.kernel_list_box.set_margin_top(5)
719	self.kernel_list_box.set_margin_left(9)
720	self.kernel_list_box.set_margin_right(9)
721
722	self.kernel_box_stack.set_visible_child_name("kernels")
723	self.update_kernels_button.set_sensitive(True)
724	self.filter_kernels_button.set_sensitive(True)
725	self.apply_kernel_button.set_sensitive(True)
726	self.entry_kernel.set_can_focus(True)
727
728	self.kernel_installed_spinner.hide()
729
730
731	self.switch_kernel_installed.show()
732	self.switch_kernel_installed.set_sensitive(True)
733
734	self.kernel_combobox.set_active(self.read_kernel_default())
735	self.kernel_combobox.show()
736	self.kernel_combobox_spinner.hide()
737	self.kernel_combobox_spinner_active=False
738
739	if not self.flag_installed:
740	self.info_box_stack.set_visible_child_name("empty_box_kernel")
741	else:
742	self.info_box_stack.set_visible_child_name("info_kernel")
743	self.txt_check_kernel.set_text(_("INSTALLED!! Your new kernel list:\n%s"%self.installed))
744	self.flag_installed=False
745
746	except Exception as e:
747	self.core.dprint("(show_kernel_results) Error: %s"%e)
748
749	#def show_kernel_results
750
751
752
753
754
755
756	def generate_element_list(self,kernel):
757	try:
758	hbox=Gtk.HBox()
759	label=Gtk.Label(kernel[0])
760	label.set_alignment(0,0)
761	#cb=Gtk.CheckButton()
762	cb=Gtk.Button()
763	cb.set_halign(Gtk.Align.END)
764	hbox.pack_start(label,True,True,0)
765	hbox.pack_end(cb,True,True,0)
766	hbox.set_margin_left(10)
767	hbox.set_margin_right(10)
768	hbox.show_all()
769	cb.label=label.get_text()
770	cb.data=kernel
771	hbox.checkbutton=cb
772	if kernel[2]:
773	#hbox.checkbutton.set_active(True)
774	hbox.checkbutton.set_label(_("Uninstall"))
775	hbox.checkbutton.set_name("UNINSTALL_BUTTON")
776	hbox.checkbutton.connect("clicked",self.uninstall_clicked)
777	else:
778	hbox.checkbutton.set_label(_("Install"))
779	hbox.checkbutton.set_name("INSTALL_BUTTON")
780	hbox.checkbutton.connect("clicked",self.install_clicked)
781
782	#hbox.set_name("PKG_BOX")
783	self.kernel_list_box.pack_start(hbox,False,False,5)
784
785	except Exception as e:
786	self.core.dprint("(generate_element_list) Error: %s"%e)
787
788	#def generate_element_list
789
790
791
792	def uninstall_clicked(self,widget):
793
794	try:
795	#CANCEL OPERATION IF THIS KERNEL IS IN USE AT THE MOMENT OR KERNEL IS IN META LLIUREX
796	kernel_file='/tmp/.uname'
797	os.system('uname -r > %s'%kernel_file)
798	f=open(kernel_file)
799	lines=f.readlines()
800	f.close()
801	os.remove(kernel_file)
802
803	for line in lines:
804	if widget.label in line:
805	mw=self.core.lri.main_window
806	d=Dialog.InfoDialog(mw,_("First Aid Kit"),_("You can't delete this kernel because you are using now."))
807	response=d.run()
808	d.destroy()
809	self.core.dprint("You can't delete this kernel because you are using now.: %s"%(widget.label))
810	self.update_kernels_button.set_sensitive(True)
811	self.filter_kernels_button.set_sensitive(True)
812	self.apply_kernel_button.set_sensitive(True)
813	self.entry_kernel.set_can_focus(True)
814	self.switch_kernel_installed.set_sensitive(True)
815
816	return True
817
818	# CANCEL OPERATION IF LLIUREX-META I AFFECTED WITH THIS OPERATION
819	kernel_file='/tmp/.uname'
820	os.system('LANG=C apt show linux-headers-generic > %s'%kernel_file)
821	f=open(kernel_file)
822	lines=f.readlines()
823	f.close()
824	os.remove(kernel_file)
825
826	for line in lines:
827	if 'Depends' in line:
828	if widget.label in line:
829	mw=self.core.lri.main_window
830	a=_("First Aid Kit")
831	b=_("You can't delete this kernel because is essential for LliureX.")
832	d=Dialog.InfoDialog(mw,a,b)
833	response=d.run()
834	d.destroy()
835	self.core.dprint("You can't delete this kernel because is essential for LliureX: %s"%(widget.label))
836	self.update_kernels_button.set_sensitive(True)
837	self.filter_kernels_button.set_sensitive(True)
838	self.apply_kernel_button.set_sensitive(True)
839	self.entry_kernel.set_can_focus(True)
840	self.switch_kernel_installed.set_sensitive(True)
841
842	return True
843
844
845
846	mw=self.core.lri.main_window
847	a = _("First Aid Kit")
848	b = _("Do you want to DELETE this kernel?\n%s"%(widget.label))
849	d=Dialog.QuestionDialog(mw,a,b)
850
851	response=d.run()
852	d.destroy()
853	if response== Gtk.ResponseType.OK:
854	self.info_box_stack.set_visible_child_name("info_kernel")
855	self.core.dprint('delete %s %s'%(widget.label,[widget.data[1],widget.data[3]]))
856	self.kernel_install('delete',widget.label,[widget.data[1],widget.data[3]])
857	else:
858	self.info_box_stack.set_visible_child_name("info_kernel")
859	self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
860	self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
861	self.update_kernels_button.set_sensitive(True)
862	self.filter_kernels_button.set_sensitive(True)
863	self.apply_kernel_button.set_sensitive(True)
864	self.entry_kernel.set_can_focus(True)
865	self.switch_kernel_installed.set_sensitive(True)
866
867	except Exception as e:
868	self.core.dprint("(uninstall_clicked) Error: %s"%e)
869	self.info_box_stack.set_visible_child_name("info_kernel")
870	self.txt_check_kernel.set_text(_("(uninstall_clicked) Error: %s"%e))
871
872	#def uninstall_clicked
873
874
875
876
877	def install_clicked(self,widget):
878
879	try:
880	mw=self.core.lri.main_window
881	d=Dialog.QuestionDialog(mw,_("First Aid Kit"),_("Do you want to INSTALL this kernel?\n%s"%(widget.label)))
882	response=d.run()
883	d.destroy()
884	if response== Gtk.ResponseType.OK:
885	self.info_box_stack.set_visible_child_name("info_kernel")
886	self.core.dprint('install %s %s'%(widget.label,[widget.data[1],widget.data[3]]))
887	self.kernel_install('install',widget.label,[widget.data[1],widget.data[3]])
888	else:
889	self.info_box_stack.set_visible_child_name("info_kernel")
890	self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
891	self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
892	self.update_kernels_button.set_sensitive(True)
893	self.filter_kernels_button.set_sensitive(True)
894	self.apply_kernel_button.set_sensitive(True)
895	self.entry_kernel.set_can_focus(True)
896	self.switch_kernel_installed.set_sensitive(True)
897
898	except Exception as e:
899	self.core.dprint("(install_clicked) Error: %s"%e)
900	self.info_box_stack.set_visible_child_name("info_kernel")
901	self.txt_check_kernel.set_text(_("(install_clicked) Error: %s"%e))
902
903	#def install_clicked
904
905
906
907
908	def kernel_install(self,action,kernel_label,packages):
909
910	try:
911	for i in self.kernel_list_box:
912	self.kernel_list_box.remove(i)
913
914	self.kernel_box_stack.set_visible_child_name("spinner")
915
916	self.entry_kernel.set_can_focus(False)
917	self.update_kernels_button.set_sensitive(False)
918	self.filter_kernels_button.set_sensitive(False)
919	self.apply_kernel_button.set_sensitive(False)
920	self.switch_kernel_installed.set_sensitive(False)
921
922	allocation=self.kernel_combobox.get_allocation()
923	w=allocation.width
924	h=allocation.height
925
926	self.kernel_combobox.hide()
927	self.kernel_combobox_spinner.start()
928	self.kernel_combobox_spinner.set_size_request(w,h)
929	self.kernel_combobox_spinner.show()
930	self.kernel_combobox_spinner_active=True
931
932	if action == 'install':
933	for app in packages:
934	#Install linux-headers and linux-generic packages
935	pkg=self.cache[app]
936	pkg.mark_install()
937	label_action='Installing'
938
939	if action == 'delete':
940	for app in packages:
941	#Delete linux-headers and linux-generic packages
942	pkg=self.cache[app]
943	pkg.mark_delete()
944	label_action='Deleting'
945
946	self.info_box_stack.set_visible_child_name("info_kernel")
947	self.txt_check_kernel.set_text(_("%s: %s Please wait....."%(label_action,kernel_label)))
948	self.core.dprint("%s: %s Please wait....."%(label_action,kernel_label))
949
950	self.thread_install=threading.Thread(target=self.kernel_install_thread)
951	self.thread_install.daemon=True
952	self.thread_install.start()
953
954	GLib.timeout_add(500,self.check_kernel_install_thread)
955
956	except Exception as e:
957	self.core.dprint("(kernel_install) Error: %s"%e)
958
959	#def install_clicked
960
961
962	def kernel_install_thread(self):
963
964	try:
965	self.core.working=True
966	self.cache.commit()
967	#os.system('update-grub2')
968	proc=subprocess.Popen('update-grub2',shell=True, stdin=None, stdout=open("/dev/null","w"), stderr=None, executable="/bin/bash")
969	proc.wait()
970	except Exception as e:
971	self.core.dprint("(kernel_install_thread) Error: %s"%e)
972
973	#def kernel_install_thread
974
975
976
977	def check_kernel_install_thread(self):
978
979	try:
980	if self.thread_install.is_alive():
981	return True
982
983	self.flag_installed=True
984	self.load_kernels()
985	self.core.working=False
986	self.core.dprint("Finished!!")
987
988	except Exception as e:
989	self.core.dprint("(check_kernel_install_thread) Error: %s"%e)
990
991	#def check_kernel_install_thread
992

Note: See TracBrowser for help on using the repository browser.

Download in other formats: