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, 12 months ago

Apply update-grub2 when you change kernel by defect

File size: 27.0 KB
Line 
1import gi
2gi.require_version('Gtk', '3.0')
3from gi.repository import Gtk, Pango, GdkPixbuf, Gdk, Gio, GObject,GLib
4
5import copy
6import gettext
7import Core
8
9import Dialog
10import time
11import threading
12import sys
13import os
14import subprocess
15import apt
16import platform
17import copy
18import shutil
19
20gettext.textdomain('first-aid-kit-gui')
21_=gettext.gettext
22
23
24RSRC="./rsrc/"
25
26
27class 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.