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

Last change on this file since 8613 was 8613, checked in by daduve, 12 months ago

KernelBox? file was modify with old version

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