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

Last change on this file since 8489 was 8489, checked in by daduve, 17 months ago

Added updategrub2

File size: 14.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
18
19gettext.textdomain('first-aid-kit-gui')
20_=gettext.gettext
21
22
23RSRC="./rsrc/"
24
25
26class KernelBox(Gtk.VBox):
27       
28       
29        def __init__(self):
30               
31                try:
32                        Gtk.VBox.__init__(self)
33               
34                        self.core=Core.Core.get_core()
35                       
36                        builder=Gtk.Builder()
37                        builder.set_translation_domain('first-aid-kit-gui')
38                        ui_path=RSRC + "first-aid-kit.ui"
39                        builder.add_from_file(ui_path)
40                       
41                       
42                        self.kernel_box=builder.get_object("kernel_box")
43                        self.kernel_label=builder.get_object("kernel_label")
44                        self.kernel_vp=builder.get_object("viewport3")
45                        self.info_box_kernel=builder.get_object("info_kernel")
46                        self.txt_check_kernel=builder.get_object("txt_check_kernel")
47                        self.spinner_info_kernel=builder.get_object("spinner_info_kernel")
48                        self.separator_kernel=builder.get_object("separator3")
49                        self.kernel_list_box=builder.get_object("box16")
50                        self.entry_kernel=builder.get_object("entry_kernel")
51                        self.update_kernels_button=builder.get_object("kernel_update_button")
52                        self.filter_kernels_button=builder.get_object("kernel_filter_button")
53                        self.apply_kernel_button=builder.get_object("apply_kernel_button")
54                       
55
56                        self.add(self.kernel_box)
57                       
58                       
59
60
61                        self.info_box_stack=Gtk.Stack()
62                        self.info_box_stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
63                        self.info_box_stack.set_transition_duration(500)
64                        hbox_kernel=Gtk.HBox()
65                        hbox_kernel.show()
66                        self.info_box_stack.add_titled(hbox_kernel,"empty_box_kernel","Empty Box Kernel")
67                        self.info_box_stack.add_titled(self.info_box_kernel,"info_kernel","InfoBoxKernel")
68
69                        self.wawabox3=Gtk.HBox()
70                        self.wawabox3.pack_start(self.info_box_stack,True,True,0)
71
72                        self.kernel_box.pack_start(self.wawabox3,False,False,5)
73
74
75                        self.info_box_kernel.set_margin_bottom(20)
76                        self.info_box_kernel.set_margin_left(5)
77                        self.info_box_kernel.set_margin_right(5)
78
79                        self.info_box_stack.set_visible_child_name("empty_box_kernel")
80
81
82                        self.kernel_box_stack=Gtk.Stack()
83                        self.kernel_box_stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
84                        self.kernel_box_stack.set_transition_duration(500)
85                        load_spinner=Gtk.Spinner()
86                        load_spinner.show()
87                        load_spinner.start()
88                        self.kernel_box_stack.add_titled(load_spinner,"spinner","")
89                        self.kernel_box_stack.add_titled(self.kernel_list_box,"kernels","")
90
91                        self.kernel_vp.add(self.kernel_box_stack)
92
93                        self.kernel_filter=''
94
95                        self.flag_installed=False
96                        self.connect_signals()
97                        self.set_css_info()
98                        self.load_kernels()
99
100                       
101                except Exception as e:
102                        self.core.dprint("Error in KernelBox: %s"%e)
103               
104        #def __init__
105       
106
107
108
109
110
111        def set_css_info(self):
112               
113                self.style_provider=Gtk.CssProvider()
114                f=Gio.File.new_for_path("first-aid-kit.css")
115                self.style_provider.load_from_file(f)
116                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
117               
118                self.info_box_kernel.set_name("PKG_BOX")
119                self.separator_kernel.set_name("SEPARATOR")
120               
121                self.kernel_list_box.set_name("PKG_BOX")
122
123                self.kernel_label.set_name("SECTION_LABEL")
124
125                self.txt_check_kernel.set_name("INFO_LABEL")
126
127                self.update_kernels_button.set_name("EXECUTE_BUTTON")
128                self.filter_kernels_button.set_name("EXECUTE_BUTTON")
129                self.apply_kernel_button.set_name("EXECUTE_BUTTON")
130                       
131        #def set-css_info
132
133
134
135
136
137        def connect_signals(self):
138               
139                self.update_kernels_button.connect("clicked",self.update_kernels_button_clicked)
140                self.apply_kernel_button.connect("clicked",self.get_checked_kernels)
141                self.filter_kernels_button.connect("clicked",self.filter_kernels_button_clicked)
142                self.entry_kernel.connect("activate",self.entries_press_event)
143               
144        #def connect_signals
145
146
147
148
149
150        def entries_press_event(self,widget):
151               
152                self.filter_kernels_button_clicked(None)
153               
154        #def entries_press_event
155
156
157
158
159
160
161
162
163        def filter_kernels_button_clicked (self,widget):
164                try:
165                        self.entry_kernel.set_can_focus(False)
166                        self.kernel_filter=self.entry_kernel.get_text().split()
167                        #print self.kernel_filter
168                        self.update_kernels_button.set_sensitive(False)
169                        self.filter_kernels_button.set_sensitive(False)
170                        self.apply_kernel_button.set_sensitive(False)
171                        self.kernel_box_stack.set_visible_child_name("spinner")
172
173                        self.info_box_stack.set_visible_child_name("info_kernel")
174                        self.txt_check_kernel.set_text(_("Applying filter to kernels...please wait"))
175                        self.core.dprint("Applying filter to kernels...")
176                        self.load_kernels()
177                       
178
179                except Exception as e:
180                        self.core.dprint("Error in update_kernels_button_clicked: %s"%e)
181
182        #def filter_kernels_button_clicked
183
184
185
186
187
188
189
190        def update_kernels_button_clicked (self,widget):
191                try:
192                        self.entry_kernel.set_can_focus(False)
193                        self.kernel_filter=self.entry_kernel.get_text().split()
194                        print self.kernel_filter
195                        self.update_kernels_button.set_sensitive(False)
196                        self.filter_kernels_button.set_sensitive(False)
197                        self.apply_kernel_button.set_sensitive(False)
198                        self.kernel_box_stack.set_visible_child_name("spinner")
199
200                        self.info_box_stack.set_visible_child_name("info_kernel")
201                        self.txt_check_kernel.set_text(_("Updating Kernel Cache...please wait"))
202                        self.core.dprint("Updating Kernel Cache...")
203                       
204                        self.thread_up=threading.Thread(target=self.update_kernels_thread)
205                        self.thread_up.daemon=True
206                        self.thread_up.start()
207
208                        GLib.timeout_add(500,self.check_update_kernels_thread)
209
210                except Exception as e:
211                        self.core.dprint("Error in update_kernels_button_clicked: %s"%e)
212
213        #def update_kernels_button_clicked
214
215
216
217        def update_kernels_thread(self):
218
219                try:
220
221                        self.cache.update()
222                               
223                except Exception as e:
224                        self.core.dprint("Error in update_kernels_thread: %s"%e)       
225
226        #def update_kernels_thread
227
228
229
230        def check_update_kernels_thread(self):
231               
232                try:
233                        if self.thread_up.is_alive():
234                                return True
235
236                        self.load_kernels()
237
238                except Exception as e:
239                        self.core.dprint("Error in check_update_kernels_thread: %s"%e)
240
241        #def check_update_kernels_thread
242
243
244
245
246
247
248
249
250        def load_kernels(self):
251
252                try:
253                        self.entry_kernel.set_can_focus(False)
254                        self.update_kernels_button.set_sensitive(False)
255                        self.filter_kernels_button.set_sensitive(False)
256                        self.apply_kernel_button.set_sensitive(False)
257                        self.read_kernels()
258                               
259                except Exception as e:
260                        self.core.dprint("Error in load_kernels: %s"%e) 
261
262        #def load_kernels
263
264
265
266
267
268
269
270        def read_kernels(self):
271
272                try:
273                        self.thread=threading.Thread(target=self.read_kernels_thread)
274                        self.thread.daemon=True
275                        self.thread.start()
276
277                        self.core.dprint("Reading kernels avaiables..........")
278
279                        GLib.timeout_add(500,self.check_read_kernels_thread)
280
281                except Exception as e:
282                        self.core.dprint("Error in read_kernels: %s"%e)
283
284        #def read_kernels
285
286
287
288        def read_kernels_thread(self):
289                try:
290
291                        platform.architecture()[0]
292                        if '64' in platform.architecture()[0]:
293                                self.arch64=True
294                        else:
295                                self.arch64=False
296
297                        self.cache=apt.cache.Cache()
298
299                        pkgs=[pkg for pkg in self.cache]
300
301                        self.avaiable=[]
302                        self.installed=[]
303
304
305                        for i in pkgs:
306                                if not 'linux-headers-generic' == str(i):
307                                        if 'linux-header' in str(i):
308                                                if 'generic' in str(i):
309                                                        version=str(i)
310                                                        linux_image=version.replace('linux-headers-','linux-image-')
311                                                        version=version.replace('linux-headers-','')
312                                                        version=version.replace('generic-','')
313                                                        version=version.replace('-generic','')
314                                                        if self.arch64:
315                                                                if  not 'i386' in str(i):
316                                                                        if self.cache[str(i)].is_installed:
317                                                                                self.installed.append(version)
318                                                                                self.avaiable.append((version,str(i),True,linux_image))
319                                                                                #print ('%s is installed'%version)
320                                                                        else:
321                                                                               
322                                                                                self.avaiable.append((version,str(i),False,linux_image))
323                                                                                #print i
324                                                        else:
325                                                                if 'i386' in str(i):
326                                                                        if self.cache[str(i)].is_installed:
327                                                                                self.installed.append(version)
328                                                                                self.avaiable.append((version,str(i),True,linux_image))
329                                                                                #print ('%s is installed'%version)
330                                                                        else:
331                                                                                self.avaiable.append((version,str(i),False,linux_image))
332
333                        self.filtered=[]
334                        if len(self.kernel_filter)>0:
335                                #print 'In filter....'
336                                for i in self.avaiable:
337                                        add=True
338                                        #print i
339                                        for option in self.kernel_filter:
340                                                #print 'Apply filter:   %s'%option
341                                                if not str(option) in str(i[1]):
342                                                        add=False
343                                        if add:
344                                                #print "** Added **"
345                                                self.filtered.append(i)
346
347                                self.avaiable=self.filtered
348
349                        #print self.avaiable
350
351                except Exception as e:
352                        self.core.dprint("Error in tread_read_kernels: %s"%e)
353
354        #def read_kernels
355
356
357        def check_read_kernels_thread(self):
358               
359                try:
360                        if self.thread.is_alive():
361                                return True
362
363                        count=len(self.avaiable)
364
365                        for i in self.kernel_list_box:
366                                self.kernel_list_box.remove(i)
367
368                        for kernel in self.avaiable:
369
370                                hbox=Gtk.HBox()
371                                label=Gtk.Label(kernel[0])
372                                label.set_alignment(0,0)
373                                cb=Gtk.CheckButton()
374                                cb.set_halign(Gtk.Align.END)
375                                hbox.pack_start(label,True,True,0)
376                                hbox.pack_end(cb,True,True,0)
377                                hbox.set_margin_left(10)
378                                hbox.set_margin_right(10)
379                                hbox.show_all()
380                                hbox.checkbutton=cb
381                                hbox.label=label.get_text()
382                                hbox.data=kernel
383                                if kernel[2]:
384                                        hbox.checkbutton.set_active(True)
385                                #hbox.set_name("PKG_BOX")
386                                self.kernel_list_box.pack_start(hbox,False,False,5)
387
388                               
389                                count-=1
390                                if count>0:
391                                        s=Gtk.Separator()
392                                        s.show()
393                                        self.kernel_list_box.pack_start(s,False,False,5)
394                                        self.kernel_list_box.set_margin_bottom(20)
395                                        self.kernel_list_box.set_margin_top(5)
396                                        self.kernel_list_box.set_margin_left(9)
397                                        self.kernel_list_box.set_margin_right(9)
398
399                        self.kernel_box_stack.set_visible_child_name("kernels")
400                        self.update_kernels_button.set_sensitive(True)
401                        self.filter_kernels_button.set_sensitive(True)
402                        self.apply_kernel_button.set_sensitive(True)
403                        self.entry_kernel.set_can_focus(True)
404                       
405                        if not self.flag_installed:
406                                self.info_box_stack.set_visible_child_name("empty_box_kernel")
407                        else:
408                                self.info_box_stack.set_visible_child_name("info_kernel")
409                                self.txt_check_kernel.set_text(_("INSTALLED!! Your new kernel list:\n%s"%self.installed))
410                                self.flag_installed=False
411
412                except Exception as e:
413                        self.core.dprint("Error in check_read_kernels_thread: %s"%e)
414        #def check_read_kernels_thread
415
416
417
418
419
420
421
422
423
424        def get_checked_kernels(self,widget=None):
425               
426                try:
427                        self.entry_kernel.set_can_focus(False)
428                        self.update_kernels_button.set_sensitive(False)
429                        self.filter_kernels_button.set_sensitive(False)
430                        self.apply_kernel_button.set_sensitive(False)
431                        self.kernel_label_selected=[]
432                        self.kernel_selected=[]
433                        self.kernel_label_delete=[]
434                        self.kernel_delete=[]
435                        flag_install=False
436                        for item in self.kernel_list_box:
437                                if type(item) == Gtk.HBox:
438                                        if item.checkbutton.get_active():
439                                                if not (item.data[2]):
440                                                        self.kernel_label_selected.append(item.label)
441                                                        self.kernel_selected.append(item.data)
442                                                        flag_install=True
443
444                                        else:
445                                                if (item.data[2]):
446                                                        #Aqui guardare los Kernels que deben borrarse
447                                                        self.kernel_delete.append(item.data)
448                                                        self.kernel_label_delete.append(item.label)
449                                                        flag_install=True
450
451                        if flag_install:
452                                mw=self.core.lri.main_window
453                                d=Dialog.QuestionDialog(mw,"First Aid Kit","Do you want to INSTALL this kernel list?\n%s\nDo you want to DELETE this kernel list?\n%s"%(self.kernel_label_selected,self.kernel_label_delete))
454                                response=d.run()
455                                d.destroy()
456                                if response== Gtk.ResponseType.OK:
457                                        self.info_box_stack.set_visible_child_name("info_kernel")
458                                        self.kernel_install()
459                                       
460                                else:
461                                        self.info_box_stack.set_visible_child_name("info_kernel")
462                                        self.txt_check_kernel.set_text(_("You cancel to install kernels"))
463                                        self.core.dprint("You cancel to install kernels")
464                                        self.update_kernels_button.set_sensitive(True)
465                                        self.filter_kernels_button.set_sensitive(True)
466                                        self.apply_kernel_button.set_sensitive(True)
467                                        self.entry_kernel.set_can_focus(True)
468                        else:
469                                mw=self.core.lri.main_window
470                                d=Dialog.InfoDialog(mw,"First Aid Kit","Sorry but you don have programmed any action\please select/unselect one kernel")
471                                d.run()
472                                d.destroy()
473                                self.update_kernels_button.set_sensitive(True)
474                                self.filter_kernels_button.set_sensitive(True)
475                                self.apply_kernel_button.set_sensitive(True)
476                                self.entry_kernel.set_can_focus(True)
477               
478
479                except Exception as e:
480                        self.core.dprint("Error in get_checked_kernels: %s"%e)
481
482
483        #def get_checked_kernesl
484       
485       
486       
487       
488        def kernel_install(self):
489                try:
490                        for app in self.kernel_selected:
491                                #install linux-headers
492                                pkg=self.cache[app[1]]
493                                pkg.mark_install()
494                                #install linux-image
495                                pkg=self.cache[app[3]]
496                                pkg.mark_install()
497                               
498                               
499                               
500                        for app in self.kernel_delete:
501                                #Delete linux-headers
502                                pkg=self.cache[app[1]]
503                                pkg.mark_delete()       
504                                #delete linux-image
505                                pkg=self.cache[app[3]]
506                                pkg.mark_delete()
507                               
508                       
509                        self.info_box_stack.set_visible_child_name("info_kernel")
510                        self.txt_check_kernel.set_text(_("Installing: %s\nDeleting: %s\nPlease wait........"%(self.kernel_label_selected,self.kernel_label_delete)))
511                        self.core.dprint("Installing: %s\n[CORE] Deleting: %s\nPlease wait........"%(self.kernel_label_selected,self.kernel_label_delete))
512                       
513                        self.thread_install=threading.Thread(target=self.kernel_install_thread)
514                        self.thread_install.daemon=True
515                        self.thread_install.start()
516
517                        GLib.timeout_add(500,self.check_kernel_install_thread)
518                       
519                       
520                except Exception as e:
521                        self.core.dprint("Error in kernel_install: %s"%e)
522               
523        #def kernel_install
524       
525       
526        def kernel_install_thread(self):
527
528                try:
529                        self.cache.commit()
530                        #os.system('update-grub2')
531                        proc=subprocess.Popen('update-grub2',shell=True, stdin=None, stdout=open("/dev/null","w"), stderr=None, executable="/bin/bash")
532                        proc.wait()
533                except Exception as e:
534                        self.core.dprint("Error in kernel_install_thread: %s"%e)       
535
536        #def kernel_install_thread
537
538
539
540        def check_kernel_install_thread(self):
541               
542                try:
543                        if self.thread_install.is_alive():
544                                return True
545                               
546                        self.flag_installed=True
547                        self.load_kernels()
548                        self.core.dprint("Finished!!")
549
550                except Exception as e:
551                        self.core.dprint("Error in check_kernel_install_thread: %s"%e)
552
553        #def check_kernel_install_thread
554       
555       
556       
557       
558       
559
Note: See TracBrowser for help on using the repository browser.