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

Last change on this file since 8615 was 8615, checked in by daduve, 2 years ago

New grub-menu script to dectect list grub menu

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"'%default_grub_option)
300                                        f_copy.write("\n")
301                                        line_writed=True
302                                else:
303                                        f_copy.write(line)
304                       
305                        if not line_writed:
306                                f_copy.write("GRUB_DEFAULT=%s\n"%default_grub_option)
307                        f_copy.close()
308
309                        shutil.copy(grub_file_tmp,grub_file)
310
311                        self.switch_kernel_installed.set_sensitive(False)
312                        self.update_kernels_button.set_sensitive(False)
313                        self.filter_kernels_button.set_sensitive(False)
314                        self.apply_kernel_button.set_sensitive(False)
315                        self.entry_kernel.set_can_focus(False)
316                        self.kernel_box_stack.set_visible_child_name("spinner")
317
318                        allocation=self.kernel_combobox.get_allocation()
319                        w=allocation.width
320                        h=allocation.height
321
322                        self.kernel_combobox.hide()
323                        self.kernel_combobox_spinner.start()
324                        self.kernel_combobox_spinner.set_size_request(w,h)
325                        self.kernel_combobox_spinner.show()
326                        self.kernel_combobox_spinner_active=True
327
328                        self.thread_install=threading.Thread(target=self.set_kernel_default_thread)
329                        self.thread_install.daemon=True
330                        self.thread_install.start()
331
332                        GLib.timeout_add(500,self.check_set_kernel_default_thread)
333
334                except Exception as e:
335                        self.core.dprint("(set_kernel_default) Error: %s"%e)
336       
337        #def set_kernel_default
338
339
340
341        def set_kernel_default_thread(self):
342
343                try:
344                        self.core.working=True
345                        proc=subprocess.Popen('update-grub2',shell=True, stdin=None, stdout=open("/dev/null","w"), stderr=None, executable="/bin/bash")
346                        proc.wait()
347                except Exception as e:
348                        self.core.dprint("(kernel_install_thread) Error: %s"%e) 
349
350        #def kernel_install_thread
351
352
353
354        def check_set_kernel_default_thread(self):
355               
356                try:
357                        if self.thread_install.is_alive():
358                                return True
359                               
360                        self.flag_installed=True
361                        self.read_kernel_default()
362                        self.core.working=False
363
364                        self.kernel_box_stack.set_visible_child_name("kernels")
365                        self.update_kernels_button.set_sensitive(True)
366                        self.filter_kernels_button.set_sensitive(True)
367                        self.apply_kernel_button.set_sensitive(True)
368                        self.entry_kernel.set_can_focus(True)
369
370                        self.kernel_installed_spinner.hide()
371                       
372
373                        self.switch_kernel_installed.show()
374                        self.switch_kernel_installed.set_sensitive(True)
375                       
376                        self.kernel_combobox.set_active(self.read_kernel_default())
377                        self.kernel_combobox.show()
378                        self.kernel_combobox_spinner.hide()
379                        self.kernel_combobox_spinner_active=False
380
381                        self.info_box_stack.set_visible_child_name("info_kernel")
382                        self.txt_check_kernel.set_text(_("You have a new kernel boot by defect: %s"%self.kernel_selected))
383                        self.core.dprint("You have a new kernel boot by defect: %s"%self.kernel_selected)
384
385                except Exception as e:
386                        self.core.dprint("(check_set_kernel_default_thread) Error: %s"%e)
387
388        #def check_kernel_install_thread
389
390
391
392
393
394
395
396        def kernel_installed_filter(self,widget,params):
397               
398                try:
399                        if self.switch_kernel_installed.get_active():
400                                self.kernel_installed_filter_active=True
401                        else:
402                                self.kernel_installed_filter_active=False
403
404                        self.switch_kernel_installed.set_sensitive(False)
405                        self.update_kernels_button.set_sensitive(False)
406                        self.filter_kernels_button.set_sensitive(False)
407                        self.apply_kernel_button.set_sensitive(False)
408                        self.entry_kernel.set_can_focus(False)
409                        self.kernel_box_stack.set_visible_child_name("spinner")
410
411
412                        allocation=self.switch_kernel_installed.get_allocation()
413                        w=allocation.width
414                        h=allocation.height
415                       
416                        self.switch_kernel_installed.hide()
417                        self.kernel_installed_spinner.start()
418                        self.kernel_installed_spinner.set_size_request(w,h)
419                        self.kernel_installed_spinner.show()
420
421                        self.info_box_stack.set_visible_child_name("info_kernel")
422                        self.txt_check_kernel.set_text(_("Applying filter to show only installed kernels...please wait"))
423                        self.core.dprint("Applying filter to show only installed kernels...please wait")
424
425                        self.show_kernel_results()
426
427                except Exception as e:
428                        self.core.dprint("(kernel_installed_filter) Error: %s"%e)
429               
430        #def kernel_installed_filter
431
432
433
434
435
436
437
438
439        def filter_kernels_button_clicked (self,widget):
440                try:
441                        self.entry_kernel.set_can_focus(False)
442                        self.kernel_filter=self.entry_kernel.get_text().split()
443                        #print self.kernel_filter
444                        self.update_kernels_button.set_sensitive(False)
445                        self.filter_kernels_button.set_sensitive(False)
446                        self.apply_kernel_button.set_sensitive(False)
447                        self.switch_kernel_installed.set_sensitive(False)
448                        self.kernel_box_stack.set_visible_child_name("spinner")
449
450                        self.info_box_stack.set_visible_child_name("info_kernel")
451                        self.txt_check_kernel.set_text(_("Applying filter to kernels...please wait"))
452                        self.core.dprint("Applying filter to kernels...")
453                        self.load_kernels()
454                       
455
456                except Exception as e:
457                        self.core.dprint("(filter_kernels_button_clicked) Error: %s"%e)
458
459        #def filter_kernels_button_clicked
460
461
462
463
464
465
466
467        def update_kernels_button_clicked (self,widget):
468                try:
469
470                        self.entry_kernel.set_can_focus(False)
471                        self.kernel_filter=self.entry_kernel.get_text().split()
472                        print self.kernel_filter
473                        self.update_kernels_button.set_sensitive(False)
474                        self.filter_kernels_button.set_sensitive(False)
475                        self.apply_kernel_button.set_sensitive(False)
476                        self.switch_kernel_installed.set_sensitive(False)
477                       
478                        for i in self.kernel_list_box:
479                                self.kernel_list_box.remove(i)
480
481                        self.kernel_box_stack.set_visible_child_name("spinner")
482                        self.kernel_box_stack.set_size_request(0,0)
483
484                        allocation=self.kernel_combobox.get_allocation()
485                        w=allocation.width
486                        h=allocation.height
487                       
488                        self.kernel_combobox.hide()
489                        self.kernel_combobox_spinner.start()
490                        self.kernel_combobox_spinner.set_size_request(w,h)
491                        self.kernel_combobox_spinner.show()
492                        self.kernel_combobox_spinner_active=True
493
494                        self.info_box_stack.set_visible_child_name("info_kernel")
495                        self.txt_check_kernel.set_text(_("Updating Kernel Cache...please wait"))
496                        self.core.dprint("Updating Kernel Cache...")
497                       
498                        self.thread_up=threading.Thread(target=self.update_kernels_thread)
499                        self.thread_up.daemon=True
500                        self.thread_up.start()
501
502                        self.kernel_vp.set_size_request(0,0)
503                        self.kernel_sw.get_vadjustment().set_page_size(0)
504                        self.kernel_sw.get_hadjustment().set_page_size(0)
505                        self.kernel_sw.set_size_request(0,0)
506                        print("hola")
507
508                        GLib.timeout_add(500,self.check_update_kernels_thread)
509
510                except Exception as e:
511                        self.core.dprint("(update_kernels_button_clicked) Error: %s"%e)
512
513        #def update_kernels_button_clicked
514
515
516
517        def update_kernels_thread(self):
518
519                try:
520
521                        self.cache.update()
522                               
523                except Exception as e:
524                        self.core.dprint("(update_kernels_thread) Error: %s"%e) 
525
526        #def update_kernels_thread
527
528
529
530        def check_update_kernels_thread(self):
531               
532                try:
533                        if self.thread_up.is_alive():
534                                return True
535
536                        self.load_kernels()
537
538                except Exception as e:
539                        self.core.dprint("(check_update_kernels_thread) Error: %s"%e)
540
541        #def check_update_kernels_thread
542
543
544
545
546
547
548
549
550        def load_kernels(self):
551
552                try:
553                        self.entry_kernel.set_can_focus(False)
554                        self.update_kernels_button.set_sensitive(False)
555                        self.filter_kernels_button.set_sensitive(False)
556                        self.apply_kernel_button.set_sensitive(False)
557                        self.switch_kernel_installed.set_sensitive(False)
558                        self.switch_kernel_installed.set_sensitive(False)
559
560
561                       
562                        self.read_kernels()
563                               
564                except Exception as e:
565                        self.core.dprint("(load_kernels) Error: %s"%e) 
566
567        #def load_kernels
568
569
570
571
572        def read_kernels(self):
573
574                try:
575                        if self.kernel_combobox_spinner_active:
576
577                                allocation=self.kernel_combobox.get_allocation()
578                                w=allocation.width
579                                h=allocation.height
580                               
581                                self.kernel_combobox.hide()
582                                self.kernel_combobox_spinner.start()
583                                self.kernel_combobox_spinner.set_size_request(w,h)
584                                self.kernel_combobox_spinner.show()
585
586                        self.thread=threading.Thread(target=self.read_kernels_thread)
587                        self.thread.daemon=True
588                        self.thread.start()
589
590                        self.core.dprint("Reading kernels avaiables..........")
591                        self.kernel_installed_boot.clear()
592                        GLib.timeout_add(500,self.check_read_kernels_thread)
593
594                except Exception as e:
595                        self.core.dprint("(read_kernels) Error: %s"%e)
596
597        #def read_kernels
598
599
600
601        def read_kernels_thread(self):
602                try:
603
604                        platform.architecture()[0]
605                        if '64' in platform.architecture()[0]:
606                                self.arch64=True
607                        else:
608                                self.arch64=False
609
610                        self.cache=apt.cache.Cache()
611
612                        pkgs=[pkg for pkg in self.cache]
613
614                        self.avaiable=[]
615                        self.installed=[]
616                        self.kernel_count_orig=0
617                       
618                        for i in pkgs:
619                                if not 'linux-headers-generic' == str(i):
620                                        if 'linux-header' in str(i):
621                                                if 'generic' in str(i):
622                                                        version=str(i)
623                                                        linux_image=version.replace('linux-headers-','linux-image-')
624                                                        version=version.replace('linux-headers-','')
625                                                        version=version.replace('generic-','')
626                                                        version=version.replace('-generic','')
627                                                        if self.arch64:
628                                                                if  not 'i386' in str(i):
629                                                                        if self.cache[str(i)].is_installed:
630                                                                                self.installed.append(version)
631                                                                                self.avaiable.append((version,str(i),True,linux_image))
632
633                                                                                self.kernel_installed_boot.append([version])
634                                                                                self.kernel_count_orig=self.kernel_count_orig+1
635                                                                                #print ('%s is installed'%version)
636                                                                        else:
637                                                                               
638                                                                                self.avaiable.append((version,str(i),False,linux_image))
639                                                                                #print i
640                                                        else:
641                                                                if 'i386' in str(i):
642                                                                        if self.cache[str(i)].is_installed:
643                                                                                self.installed.append(version)
644                                                                                self.avaiable.append((version,str(i),True,linux_image))
645                                                                                self.kernel_installed_boot.append([version])
646                                                                                self.kernel_count_orig=self.kernel_count_orig+1
647                                                                                #print ('%s is installed'%version)
648                                                                        else:
649                                                                                self.avaiable.append((version,str(i),False,linux_image))
650
651                        #self.kernel_boot()
652                        self.filtered=[]
653                        if len(self.kernel_filter)>0:
654                                #print 'In filter....'
655                                for i in self.avaiable:
656                                        add=True
657                                        #print i
658                                        for option in self.kernel_filter:
659                                                #print 'Apply filter:   %s'%option
660                                                if not str(option) in str(i[1]):
661                                                        add=False
662                                        if add:
663                                                #print "** Added **"
664                                                self.filtered.append(i)
665
666                                self.avaiable=self.filtered
667
668
669
670                        #print self.avaiable
671
672                except Exception as e:
673                        self.core.dprint("(read_kernels_thread) Error: %s"%e)
674
675        #def read_kernels
676
677
678        def check_read_kernels_thread(self):
679               
680                try:
681                        if self.thread.is_alive():
682                                return True
683
684                        self.show_kernel_results()
685
686                except Exception as e:
687                        self.core.dprint("(check_read_kernels_thread) Error: %s"%e)
688
689        #def check_read_kernels_thread
690
691
692
693
694        def show_kernel_results(self):
695                try:
696
697                        #count=len(self.avaiable)
698                        count=0
699
700                        for i in self.kernel_list_box:
701                                self.kernel_list_box.remove(i)
702
703                        for kernel in self.avaiable:
704
705                                if self.kernel_installed_filter_active:
706                                        if kernel[2]:
707                                                count=count+1
708                                                self.generate_element_list(kernel)
709                                else:
710                                        count=count+1
711                                        self.generate_element_list(kernel)
712                               
713                                count-=1
714                                if count>0:
715                                        s=Gtk.Separator()
716                                        s.show()
717                                        self.kernel_list_box.pack_start(s,False,False,5)
718                                        self.kernel_list_box.set_margin_bottom(20)
719                                        self.kernel_list_box.set_margin_top(5)
720                                        self.kernel_list_box.set_margin_left(9)
721                                        self.kernel_list_box.set_margin_right(9)
722
723                        self.kernel_box_stack.set_visible_child_name("kernels")
724                        self.update_kernels_button.set_sensitive(True)
725                        self.filter_kernels_button.set_sensitive(True)
726                        self.apply_kernel_button.set_sensitive(True)
727                        self.entry_kernel.set_can_focus(True)
728
729                        self.kernel_installed_spinner.hide()
730                       
731
732                        self.switch_kernel_installed.show()
733                        self.switch_kernel_installed.set_sensitive(True)
734                       
735                        self.kernel_combobox.set_active(self.read_kernel_default())
736                        self.kernel_combobox.show()
737                        self.kernel_combobox_spinner.hide()
738                        self.kernel_combobox_spinner_active=False
739                       
740                        if not self.flag_installed:
741                                self.info_box_stack.set_visible_child_name("empty_box_kernel")
742                        else:
743                                self.info_box_stack.set_visible_child_name("info_kernel")
744                                self.txt_check_kernel.set_text(_("INSTALLED!! Your new kernel list:\n%s"%self.installed))
745                                self.flag_installed=False
746
747                except Exception as e:
748                        self.core.dprint("(show_kernel_results) Error: %s"%e)
749       
750        #def show_kernel_results
751
752
753
754
755
756
757        def generate_element_list(self,kernel):
758                try:
759                        hbox=Gtk.HBox()
760                        label=Gtk.Label(kernel[0])
761                        label.set_alignment(0,0)
762                        #cb=Gtk.CheckButton()
763                        cb=Gtk.Button()
764                        cb.set_halign(Gtk.Align.END)
765                        hbox.pack_start(label,True,True,0)
766                        hbox.pack_end(cb,True,True,0)
767                        hbox.set_margin_left(10)
768                        hbox.set_margin_right(10)
769                        hbox.show_all()
770                        cb.label=label.get_text()
771                        cb.data=kernel
772                        hbox.checkbutton=cb
773                        if kernel[2]:
774                                #hbox.checkbutton.set_active(True)
775                                hbox.checkbutton.set_label(_("Uninstall"))
776                                hbox.checkbutton.set_name("UNINSTALL_BUTTON")
777                                hbox.checkbutton.connect("clicked",self.uninstall_clicked)
778                        else:
779                                hbox.checkbutton.set_label(_("Install"))
780                                hbox.checkbutton.set_name("INSTALL_BUTTON")
781                                hbox.checkbutton.connect("clicked",self.install_clicked)
782                       
783                        #hbox.set_name("PKG_BOX")
784                        self.kernel_list_box.pack_start(hbox,False,False,5)
785
786                except Exception as e:
787                        self.core.dprint("(generate_element_list) Error: %s"%e)
788       
789        #def generate_element_list
790
791
792
793        def uninstall_clicked(self,widget):
794
795                try:
796                        #CANCEL OPERATION IF THIS KERNEL IS IN USE AT THE MOMENT OR KERNEL IS IN META LLIUREX
797                        kernel_file='/tmp/.uname'
798                        os.system('uname -r > %s'%kernel_file)
799                        f=open(kernel_file)
800                        lines=f.readlines()
801                        f.close()
802                        os.remove(kernel_file)
803
804                        for line in lines:
805                                if widget.label in line:
806                                        mw=self.core.lri.main_window
807                                        d=Dialog.InfoDialog(mw,_("First Aid Kit"),_("You can't delete this kernel because you are using now."))
808                                        response=d.run()
809                                        d.destroy()
810                                        self.core.dprint("You can't delete this kernel because you are using now.: %s"%(widget.label))
811                                        self.update_kernels_button.set_sensitive(True)
812                                        self.filter_kernels_button.set_sensitive(True)
813                                        self.apply_kernel_button.set_sensitive(True)
814                                        self.entry_kernel.set_can_focus(True)
815                                        self.switch_kernel_installed.set_sensitive(True)
816
817                                        return True
818
819                        # CANCEL OPERATION IF LLIUREX-META I AFFECTED WITH THIS OPERATION
820                        kernel_file='/tmp/.uname'
821                        os.system('LANG=C apt show linux-headers-generic > %s'%kernel_file)
822                        f=open(kernel_file)
823                        lines=f.readlines()
824                        f.close()
825                        os.remove(kernel_file)
826
827                        for line in lines:
828                                if 'Depends' in line:
829                                        if widget.label in line:
830                                                mw=self.core.lri.main_window
831                                                a=_("First Aid Kit")
832                                                b=_("You can't delete this kernel because is essential for LliureX.")
833                                                d=Dialog.InfoDialog(mw,a,b)
834                                                response=d.run()
835                                                d.destroy()
836                                                self.core.dprint("You can't delete this kernel because is essential for LliureX: %s"%(widget.label))
837                                                self.update_kernels_button.set_sensitive(True)
838                                                self.filter_kernels_button.set_sensitive(True)
839                                                self.apply_kernel_button.set_sensitive(True)
840                                                self.entry_kernel.set_can_focus(True)
841                                                self.switch_kernel_installed.set_sensitive(True)
842
843                                                return True
844
845
846
847                        mw=self.core.lri.main_window
848                        a = _("First Aid Kit")
849                        b = _("Do you want to DELETE this kernel?\n%s"%(widget.label))
850                        d=Dialog.QuestionDialog(mw,a,b)
851
852                        response=d.run()
853                        d.destroy()
854                        if response== Gtk.ResponseType.OK:
855                                self.info_box_stack.set_visible_child_name("info_kernel")
856                                self.core.dprint('delete    %s      %s'%(widget.label,[widget.data[1],widget.data[3]]))
857                                self.kernel_install('delete',widget.label,[widget.data[1],widget.data[3]])                             
858                        else:
859                                self.info_box_stack.set_visible_child_name("info_kernel")
860                                self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
861                                self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
862                                self.update_kernels_button.set_sensitive(True)
863                                self.filter_kernels_button.set_sensitive(True)
864                                self.apply_kernel_button.set_sensitive(True)
865                                self.entry_kernel.set_can_focus(True)
866                                self.switch_kernel_installed.set_sensitive(True)
867
868                except Exception as e:
869                        self.core.dprint("(uninstall_clicked) Error: %s"%e)
870                        self.info_box_stack.set_visible_child_name("info_kernel")
871                        self.txt_check_kernel.set_text(_("(uninstall_clicked) Error: %s"%e))
872
873        #def uninstall_clicked
874
875
876
877
878        def install_clicked(self,widget):
879
880                try:
881                        mw=self.core.lri.main_window
882                        d=Dialog.QuestionDialog(mw,_("First Aid Kit"),_("Do you want to INSTALL this kernel?\n%s"%(widget.label)))
883                        response=d.run()
884                        d.destroy()
885                        if response== Gtk.ResponseType.OK:
886                                self.info_box_stack.set_visible_child_name("info_kernel")
887                                self.core.dprint('install    %s      %s'%(widget.label,[widget.data[1],widget.data[3]]))
888                                self.kernel_install('install',widget.label,[widget.data[1],widget.data[3]])                     
889                        else:
890                                self.info_box_stack.set_visible_child_name("info_kernel")
891                                self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
892                                self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
893                                self.update_kernels_button.set_sensitive(True)
894                                self.filter_kernels_button.set_sensitive(True)
895                                self.apply_kernel_button.set_sensitive(True)
896                                self.entry_kernel.set_can_focus(True)
897                                self.switch_kernel_installed.set_sensitive(True)
898
899                except Exception as e:
900                        self.core.dprint("(install_clicked) Error: %s"%e)
901                        self.info_box_stack.set_visible_child_name("info_kernel")
902                        self.txt_check_kernel.set_text(_("(install_clicked) Error: %s"%e))
903
904        #def install_clicked
905
906
907
908
909        def kernel_install(self,action,kernel_label,packages):
910
911                try:
912                        for i in self.kernel_list_box:
913                                self.kernel_list_box.remove(i)
914
915                        self.kernel_box_stack.set_visible_child_name("spinner")
916
917                        self.entry_kernel.set_can_focus(False)
918                        self.update_kernels_button.set_sensitive(False)
919                        self.filter_kernels_button.set_sensitive(False)
920                        self.apply_kernel_button.set_sensitive(False)
921                        self.switch_kernel_installed.set_sensitive(False)
922
923                        allocation=self.kernel_combobox.get_allocation()
924                        w=allocation.width
925                        h=allocation.height
926                       
927                        self.kernel_combobox.hide()
928                        self.kernel_combobox_spinner.start()
929                        self.kernel_combobox_spinner.set_size_request(w,h)
930                        self.kernel_combobox_spinner.show()
931                        self.kernel_combobox_spinner_active=True
932
933                        if action == 'install':
934                                for app in packages:
935                                        #Install linux-headers and linux-generic packages
936                                        pkg=self.cache[app]
937                                        pkg.mark_install()
938                                        label_action='Installing'
939
940                        if action == 'delete':
941                                for app in packages:
942                                        #Delete linux-headers and linux-generic packages
943                                        pkg=self.cache[app]
944                                        pkg.mark_delete()
945                                        label_action='Deleting'
946
947                        self.info_box_stack.set_visible_child_name("info_kernel")
948                        self.txt_check_kernel.set_text(_("%s: %s  Please wait....."%(label_action,kernel_label)))
949                        self.core.dprint("%s: %s  Please wait....."%(label_action,kernel_label))
950                       
951                        self.thread_install=threading.Thread(target=self.kernel_install_thread)
952                        self.thread_install.daemon=True
953                        self.thread_install.start()
954
955                        GLib.timeout_add(500,self.check_kernel_install_thread)
956
957                except Exception as e:
958                        self.core.dprint("(kernel_install) Error: %s"%e)
959
960        #def install_clicked
961
962
963        def kernel_install_thread(self):
964
965                try:
966                        self.core.working=True
967                        self.cache.commit()
968                        #os.system('update-grub2')
969                        proc=subprocess.Popen('update-grub2',shell=True, stdin=None, stdout=open("/dev/null","w"), stderr=None, executable="/bin/bash")
970                        proc.wait()
971                except Exception as e:
972                        self.core.dprint("(kernel_install_thread) Error: %s"%e) 
973
974        #def kernel_install_thread
975
976
977
978        def check_kernel_install_thread(self):
979               
980                try:
981                        if self.thread_install.is_alive():
982                                return True
983                               
984                        self.flag_installed=True
985                        self.load_kernels()
986                        self.core.working=False
987                        self.core.dprint("Finished!!")
988
989                except Exception as e:
990                        self.core.dprint("(check_kernel_install_thread) Error: %s"%e)
991
992        #def check_kernel_install_thread
993
Note: See TracBrowser for help on using the repository browser.