source: lliurex-up/trunk/fuentes/lliurex-up/usr/share/lliurex-up/lliurex-up.py @ 7635

Last change on this file since 7635 was 7635, checked in by jrpelegrina, 17 months ago

Added message when blockages are detected but there is some process running

  • Property svn:executable set to *
File size: 52.4 KB
Line 
1#!/usr/bin/env python
2import gi
3gi.require_version('Gtk', '3.0')
4gi.require_version('PangoCairo', '1.0')
5gi.require_version('Vte', '2.91')
6
7import cairo
8import os
9import shutil
10import threading
11import ConfigParser
12import platform
13import subprocess
14import sys
15import time
16import commands
17from gi.repository import Gtk, Gdk, GdkPixbuf, GObject, GLib, PangoCairo, Pango, Vte
18
19
20import LliurexUpConnect
21
22import signal
23signal.signal(signal.SIGINT, signal.SIG_DFL)
24
25import gettext
26gettext.textdomain('lliurex-up')
27_ = gettext.gettext
28
29
30
31BASE_DIR="/usr/share/lliurex-up/"
32GLADE_FILE=BASE_DIR+"rsrc/lliurex-up.ui"
33CACHED_ICON=BASE_DIR+"rsrc/cached.png"
34DONE_ICON=BASE_DIR+"rsrc/done.png"
35ERROR_ICON=BASE_DIR+"rsrc/error.png"
36NEWPACKAGE_ICON=BASE_DIR +"rsrc/newpackage.png"
37UPDATEPACKAGE_ICON=BASE_DIR + "rsrc/updatepackage.png" 
38DESKTOP_PATH="/usr/share/applications"
39LOCK_PATH="/var/run/lliurexUp.lock"
40DISABLE_INDICATOR_PATH="/etc/lliurex-up-indicator"
41DISABLE_INDICATOR_TOKEN=os.path.join(DISABLE_INDICATOR_PATH,'disableIndicator.token')
42TERMINAL_CONFIG=BASE_DIR+"terminal_config"
43
44
45
46class Package:
47
48        #def __init__(self,name,version,size,desktop_file,changelog_file):
49        def __init__(self,installed,name,version,size):
50                self.name=name
51                self.version=version
52                self.size=size
53                desktop_file=os.path.join(DESKTOP_PATH,name+".desktop")
54                self.parse_desktop(desktop_file)
55                #self.parse_changelog(changelog_file)
56                self.parse_installed_icon(CACHED_ICON)
57                self.parse_newpackage_icon(installed)
58
59        #def__init__
60       
61        def parse_desktop(self,desktop_file):
62               
63                try:
64                        config = ConfigParser.ConfigParser()
65                        config.optionxform=str
66
67                        config.read(desktop_file)
68                       
69                        #Zomandos may include a desktop file of type zomando with info for the store. Those desktops must be skipped
70                        if config.has_section("Desktop Entry") and config.has_option("Desktop Entry","Icon") and config.get("Desktop Entry","Type").lower()!="zomando":
71                                self.icon=config.get("Desktop Entry","Icon")
72                                icon_extension=os.path.splitext(self.icon)[1]
73                                if icon_extension==".xpm":
74                                        self.icon="package"
75                        else:
76                                self.icon="package"
77                               
78                except Exception as e:
79                       
80                        self.icon="package"
81                       
82        #def parse_desktop
83
84        '''
85        def parse_changelog(self,changelog_file):
86               
87                try:
88                       
89                        f=open(changelog_file,"r")
90                        self.changelog=f.readlines()
91                        f.close()
92                                               
93                except Exception as e:
94                       
95                        self.changelog="Changelog not found"
96
97        #def parse_changelog
98        '''
99       
100        def parse_installed_icon(self, icon_file):
101               
102                        image=Gtk.Image()
103                        image.set_from_file(icon_file)         
104                        self.installed=image.get_pixbuf()
105
106
107        #def parse_installed_icon
108
109
110        def parse_newpackage_icon(self, installed):
111               
112                        image=Gtk.Image()
113                        if installed==str(None):
114                                icon_file=NEWPACKAGE_ICON
115                        else:
116                                icon_file=UPDATEPACKAGE_ICON
117
118                        image.set_from_file(icon_file)         
119                        self.type=image.get_pixbuf()
120
121
122class LliurexUp:
123
124        def __init__(self):
125               
126                #self.free_space_check()
127                self.llxup_connect=LliurexUpConnect.LliurexUpConnect()
128                self.check_root()
129                self.isLliurexUpLocked()
130                                       
131        #def __init__           
132
133
134        def isLliurexUpLocked(self):
135
136                print "  [Lliurex-Up]: Checking if LliureX-Up is running..."
137
138                code=self.llxup_connect.isLliurexUpLocked()
139
140                if code !=0:
141                        message="Lliurex-Up"+self.getMessageDialog(code)
142                        self.showMessageDialog(code,message)
143                else:
144                        self.isAptLocked()     
145               
146        #def islliurexup_running       
147
148
149        def isAptLocked(self):
150
151                print "  [Lliurex-Up]: Checking if Apt is running..."
152
153                code=self.llxup_connect.isAptLocked()
154
155                if code !=0:
156                        message="Apt"+self.getMessageDialog(code)
157                        self.showMessageDialog(code,message)
158               
159                else:
160                        self.isDpkgLocked()
161       
162        #def isAptLocked               
163
164
165        def isDpkgLocked(self):
166
167                print "  [Lliurex-Up]: Checking if Dpkg is running..."
168
169                code=self.llxup_connect.isDpkgLocked()
170
171                if code !=0:
172                        tmp_msg=self.getMessageDialog(code)
173                        if code!=3:
174                                message="Dpkg"+tmp_msg
175                        else:
176                                message=tmp_msg
177
178                        self.showMessageDialog(code,message)
179                else:
180                        self.llxup_connect.startLliurexUp()
181                        self.start_gui()
182                               
183
184        #def isDpkgLocked       
185
186
187        def getMessageDialog(self,code):
188
189                if code==1:
190                        msg=_(" is now running. Wait a moment and try again")
191                elif code==2:
192                        msg=_(" seems blocked by a failed previous execution.\nLliurex-Up can not continue if this block is maintained.\nDo you want to try to unlock it? ")
193                elif code==3:
194                        msg=_("Apt is now running. Wait a moment and try again")
195
196                return msg
197
198        #def getMessageDialog                                   
199
200        def showMessageDialog(self,code,message):
201
202                if code!=2:
203                        dialog_type=Gtk.MessageType.INFO
204                        dialog_buttons=Gtk.ButtonsType.CANCEL
205                else:
206                        dialog_type=Gtk.MessageType.WARNING
207                        dialog_buttons=Gtk.ButtonsType.YES_NO   
208
209       
210                dialog = Gtk.MessageDialog(None,0,dialog_type, dialog_buttons, "Lliurex-Up")
211                dialog.format_secondary_text(message)
212                if code!=2:
213                        dialog.run()
214                        sys.exit(1)
215                else:
216                        response=dialog.run()
217                        dialog.destroy()
218                        if response==Gtk.ResponseType.YES:
219                                GObject.threads_init()
220                                self.unlocking_t=threading.Thread(target=self.unlocking_process)
221                                self.unlocking_t.daemon=True
222                                self.unlocking_t.launched=False
223                                self.unlocking_t.done=False
224                                GLib.timeout_add(100,self.pulsate_unlocking_process)
225                                self.showProgressDialog()
226                               
227
228                        else:
229                                sys.exit(1)             
230               
231                                       
232        #def showMessageDialog                         
233
234        def showProgressDialog(self):
235
236                self.unlocking_dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.INFO, Gtk.ButtonsType.CANCEL, "Lliurex-Up")
237                self.unlocking_dialog.set_size_request(510, 40)
238                self.unlocking_dialog.format_secondary_text(_("The unlocking process is running. Wait a moment..."))
239                self.unlocking_dialog_pbar=Gtk.ProgressBar()
240                self.unlocking_dialog_pbar.set_margin_left(15)
241                self.unlocking_dialog_pbar.set_margin_right(15)
242
243                self.unlocking_dialog_pbar.show()
244               
245                self.unlocking_dialog.get_children()[0].pack_start(self.unlocking_dialog_pbar,False,False,20)
246                self.unlocking_dialog.get_children()[0].get_children()[2].hide()
247                self.unlocking_dialog.run()
248
249        #def showProgressDialog
250
251
252        def pulsate_unlocking_process(self):
253
254
255                if not self.unlocking_t.launched:
256                        self.unlocking_t.launched=True
257                        self.unlocking_t.start()
258                       
259
260                if self.unlocking_t.done:
261                        self.unlocking_dialog.destroy() 
262                        if self.result_unlocking !=0:
263                                if self.result_unlocking==1:
264                                        dialog_type=Gtk.MessageType.ERROR
265                                        message=_("The unlocking process has failed")
266                                else:
267                                        dialog_type=Gtk.MessageType.INFO
268                                        message=_("Some process are running. Wait a moment and try again")     
269                                       
270                                dialog=Gtk.MessageDialog(None,0,dialog_type, Gtk.ButtonsType.CANCEL, "Lliurex-Up")
271                                dialog.format_secondary_text(message)
272                                dialog.run()
273                                sys.exit(1)
274                        else:           
275                                os.execl(sys.executable, sys.executable, *sys.argv)     
276
277                if self.unlocking_t.launched:
278                        if not self.unlocking_t.done:
279                                self.unlocking_dialog_pbar.pulse()
280                                return True             
281
282
283        #def pulsate_unlocking_process 
284
285
286        def unlocking_process(self):
287
288                self.result_unlocking=self.llxup_connect.unlockingProcess()
289                self.unlocking_t.done=True
290
291        #def unlocking_process
292
293        def check_root(self):
294               
295                try:
296                        print "  [Lliurex-Up]: Checking root"
297                        f=open("/etc/lliurex-up.token","w")
298                        f.close()
299                        os.remove("/etc/lliurex-up.token")
300                except:
301                        print "  [Lliurex-Up]: No administration privileges"
302                        dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.ERROR, Gtk.ButtonsType.CANCEL, "Lliurex-Up")
303                        dialog.format_secondary_text(_("You need administration privileges to run this application."))
304                        dialog.run()
305                        sys.exit(1)
306               
307        #def check_root
308
309        '''
310        def free_space_check(self):
311               
312                if ((os.statvfs("/").f_bfree * os.statvfs("/").f_bsize) / (1024*1024*1024)) < 2: #less than 2GB available?
313                        return False
314                       
315                        md = Gtk.MessageDialog(None, 0,Gtk.MessageType.ERROR, Gtk.ButtonsType.CANCEL," Lliurex UP")
316                        md.format_secondary_text(_("There's not enough space on disk to upgrade (2 GB needed)"))
317                        md.run()
318                        md.destroy()
319                        sys.exit(1)
320                       
321                else:
322                        return True     
323
324        # def free_space_check
325        '''
326                       
327        def start_gui(self):
328               
329                builder=Gtk.Builder()
330                builder.set_translation_domain('lliurex-up')
331
332                glade_path=GLADE_FILE
333                builder.add_from_file(glade_path)
334
335                self.stack = Gtk.Stack()
336                self.stack.set_transition_duration(1000)
337                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
338
339
340                self.window=builder.get_object("main_window")
341                self.window.resize(640,769)
342                self.main_box=builder.get_object("main_box")
343                self.pbar=builder.get_object("progressbar")
344                self.pbar_label=builder.get_object("progressbar_label")
345               
346
347                self.cancel_button_box=builder.get_object("cancel_button_box")
348                self.cancel_button_eb=builder.get_object("cancel_button_eventbox")
349                self.cancel_button_eb.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK )
350                self.cancel_button_eb.connect("button-press-event", self.quit)
351                self.cancel_button_eb.connect("motion-notify-event", self.mouse_over_cancel)
352                self.cancel_button_eb.connect("leave-notify-event", self.mouse_exit_cancel)
353                self.cancel_button_label=builder.get_object("cancel_button_label")
354
355                self.indicator_box=builder.get_object("indicator_box")
356                self.indicator_label=builder.get_object("indicator_label")
357                self.indicator_switch=builder.get_object("indicator_switch")
358
359               
360                if os.path.exists(DISABLE_INDICATOR_TOKEN):
361                        self.indicator_switch.set_active(False)
362                else:
363                        self.indicator_switch.set_active(True)
364       
365               
366
367                self.gather_box=builder.get_object("gather_box")
368                self.yes_button_box=builder.get_object("yes_button_box")
369                self.yes_button_eb=builder.get_object("yes_button_eventbox")
370                self.yes_button_eb.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK )
371                self.yes_button_eb.connect("button-release-event", self.yes_button_clicked)
372                self.yes_button_eb.connect("motion-notify-event", self.mouse_over_yes)
373                self.yes_button_eb.connect("leave-notify-event", self.mouse_exit_yes)
374                self.yes_button_label=builder.get_object("yes_button_label")
375
376                self.no_button_box=builder.get_object("no_button_box")
377                self.no_button_eb=builder.get_object("no_button_eventbox")
378                self.no_button_eb.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK )
379                self.no_button_eb.connect("button-release-event", self.no_button_clicked)
380                self.no_button_eb.connect("motion-notify-event", self.mouse_over_no)
381                self.no_button_eb.connect("leave-notify-event",self.mouse_exit_no)
382                self.no_button_label=builder.get_object("no_button_label")
383                self.gather_logo_box=builder.get_object("gather_logo_box")
384                self.gather_label=builder.get_object("gather_label")
385                self.spinner=builder.get_object("spinner")
386
387                self.update_box=builder.get_object("update_box")
388                self.current_version_label=builder.get_object("current_version_label")
389                self.current_version_label_info=builder.get_object("current_version_info_label")
390                self.version_available_label=builder.get_object("version_available_label")
391                self.version_available_label_info=builder.get_object("version_available_info_label")
392                self.version_update_label=builder.get_object("version_update_label")
393                self.version_update_label_info=builder.get_object("version_update_info_label")
394                self.number_packages_label=builder.get_object("number_packages_label")
395                self.number_packages_label_info=builder.get_object("number_packages_info_label")
396
397                self.size_update_label=builder.get_object("size_update_label")
398                self.size_update_label_info=builder.get_object("size_update_info_label")
399
400                self.view_packages_button_box=builder.get_object("view_packages_button_box")
401                self.view_packages_eb=builder.get_object("view_packages_eventbox")
402                self.view_packages_eb.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK )
403                self.view_packages_eb.connect("button-release-event", self.view_packages_clicked)
404                self.view_packages_eb.connect("motion-notify-event", self.mouse_over_view_packages)
405                self.view_packages_eb.connect("leave-notify-event", self.mouse_exit_view_packages)
406
407                self.view_packages_label=builder.get_object("view_packages_label")
408
409                self.update_button_box=builder.get_object("update_button_box")
410                self.update_button_eb=builder.get_object("update_button_eventbox")
411                self.update_button_eb.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK)
412                self.update_button_eb.connect("button-release-event", self.upgrade_process)
413                self.update_button_eb.connect("motion-notify-event", self.mouse_over_update_button)
414                self.update_button_eb.connect("leave-notify-event", self.mouse_exit_update_button)
415
416                self.update_button_label=builder.get_object("update_button_label")
417                self.update_button_label.set_label(_("Update now"))
418                self.update_button_label.set_width_chars(20)
419                self.update_button_label.set_max_width_chars(20)
420
421                self.terminal_label=builder.get_object("terminal_label")
422                self.viewport=builder.get_object("viewport")
423                self.terminal_scrolled=builder.get_object("terminalScrolledWindow")
424                self.vterminal=Vte.Terminal()
425                self.vterminal.spawn_sync(
426                        Vte.PtyFlags.DEFAULT,
427                        os.environ['HOME'],
428                        #["/usr/sbin/dpkg-reconfigure", "xdm"],
429                        ["/bin/bash","--rcfile",TERMINAL_CONFIG],
430                        [],
431                        GLib.SpawnFlags.DO_NOT_REAP_CHILD,
432                        None,
433                        None,
434                )
435                font_terminal = Pango.FontDescription("monospace normal 10")
436                self.vterminal.set_font(font_terminal)
437                self.vterminal.set_scrollback_lines(-1)
438                self.vterminal.set_sensitive(False)
439                self.terminal_scrolled.add(self.vterminal)
440               
441
442                self.packages_box=builder.get_object("packages_box")
443                self.return_arrow_box=builder.get_object("return_arrow_box")
444                self.return_arrow_eb=builder.get_object("return_arrow_eventbox")
445                self.return_arrow_eb.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK)
446                self.return_arrow_eb.connect("button-release-event", self.arrow_clicked)
447                self.return_arrow_eb.connect("motion-notify-event",self.mouse_over_return_arrow)
448                self.return_arrow_eb.connect("leave-notify-event",self.mouse_exit_return_arrow)
449                self.packages_label=builder.get_object("packages_label")
450                self.packages_tv=builder.get_object("packages_treeview")
451                self.changelog_texview=builder.get_object("changelog_textview")
452
453                #self.packages_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf)
454                self.packages_store=Gtk.ListStore(GdkPixbuf.Pixbuf,str,str,str,GdkPixbuf.Pixbuf)
455                self.packages_tv.set_model(self.packages_store)
456
457                column=Gtk.TreeViewColumn("")
458                cell=Gtk.CellRendererPixbuf()
459                column.pack_start(cell,True)
460                column.add_attribute(cell,"pixbuf",0)
461                self.packages_tv.append_column(column)
462
463                column=Gtk.TreeViewColumn("")
464                cell=Gtk.CellRendererPixbuf()
465                cell.set_property("stock-size",Gtk.IconSize.DIALOG)
466                column.pack_start(cell,True)
467                column.add_attribute(cell,"icon-name",1)
468                self.packages_tv.append_column(column)
469               
470                column=Gtk.TreeViewColumn(_("Package"))
471                cell=Gtk.CellRendererText()
472                column.pack_start(cell,True)
473                column.add_attribute(cell,"markup",2)
474                column.set_expand(True)
475
476               
477                self.packages_tv.append_column(column)
478                self.packages_tv.connect("button-release-event",self.package_clicked)
479               
480                column=Gtk.TreeViewColumn(_("Size"))
481                cell=Gtk.CellRendererText()
482                cell.set_property("alignment",Pango.Alignment.CENTER)
483                column.pack_start(cell,False)
484                column.add_attribute(cell,"markup",3)
485                self.packages_tv.append_column(column)         
486
487
488                # done_icon=Gtk.Image()
489                # done_icon.set_from_file(CACHED_ICON)
490                # pixbuf=done_icon.get_pixbuf()
491                column=Gtk.TreeViewColumn(_("State"))
492                cell=Gtk.CellRendererPixbuf()
493                column.pack_start(cell,True)
494                column.add_attribute(cell,"pixbuf",4)
495                self.packages_tv.append_column(column)
496               
497                self.changelog_textview=builder.get_object("changelog_textview")
498                self.changelog_label=builder.get_object("changelog_label")
499
500
501                self.stack.add_titled(self.gather_box,"gather","Gather")
502                self.stack.add_titled(self.update_box,"update", "Update")
503                self.stack.add_titled(self.packages_box, "packages", "Packages")
504
505                self.main_box.pack_start(self.stack,True,False,5)
506
507                self.window.show_all()
508                self.terminal_scrolled.hide()
509                self.viewport.hide()
510                self.terminal_label.hide()
511                self.cancel_button_box.hide()
512                self.indicator_box.hide()
513                self.yes_button_box.hide()
514                self.no_button_box.hide()
515
516                self.pbar_label.show()
517                self.pbar.show()
518               
519                self.window.connect("destroy",self.quit)
520               
521                self.set_css_info()
522
523                msg_gather="<span><b>"+_("Checking system")+"</b></span>"
524                self.gather_label.set_markup(msg_gather)
525                GLib.timeout_add(100,self.pulsate_checksystem)
526
527                self.initactions_process_t=threading.Thread(target=self.initActions_process)
528                self.check_lliurexup_t=threading.Thread(target=self.check_lliurexup_version)
529                self.install_lliurexup_t=threading.Thread(target=self.install_lliurexup)
530                self.check_mirror_t=threading.Thread(target=self.check_mirror)
531                #self.wait_response_t=threading.Thread(target=self.wait_response)
532                self.execute_lliurexmirror_t=threading.Thread(target=self.execute_lliurexmirror)
533                self.get_lliurexversionlocal_t=threading.Thread(target=self.get_lliurexversionlocal)
534                self.get_lliurexversionnet_t=threading.Thread(target=self.get_lliurexversionnet)
535                self.checkInitialFlavourToInstall_t=threading.Thread(target=self.checkInitialFlavourToInstall)
536                self.gather_packages_t=threading.Thread(target=self.gather_packages)
537                self.preactions_process_t=threading.Thread(target=self.preactions_process)
538                self.update_process_t=threading.Thread(target=self.update_process)
539                self.checkFinalFlavourToInstall_t=threading.Thread(target=self.checkFinalFlavourToInstall)
540                self.postactions_process_t=threading.Thread(target=self.postactions_process)
541
542                self.initactions_process_t.daemon=True
543                self.check_lliurexup_t.daemon=True
544                self.install_lliurexup_t.daemon=True
545                self.check_mirror_t.daemon=True
546                #self.wait_response_t.daemon=True
547                self.execute_lliurexmirror_t.daemon=True
548                self.get_lliurexversionlocal_t.daemon=True
549                self.get_lliurexversionnet_t.daemon=True
550                self.checkInitialFlavourToInstall_t.daemon=True
551                self.gather_packages_t.daemon=True
552                self.preactions_process_t.daemon=True
553                self.update_process_t.daemon=True
554                self.checkFinalFlavourToInstall_t.daemon=True
555                self.postactions_process_t.daemon=True
556
557                self.initactions_process_t.done=False
558                self.check_lliurexup_t.done=False
559                self.install_lliurexup_t.done=False
560                self.check_mirror_t.done=False
561                #self.wait_response_t.done=False
562                self.execute_lliurexmirror_t.done=False
563                self.get_lliurexversionlocal_t.done=False
564                self.get_lliurexversionnet_t.done=False
565                self.checkInitialFlavourToInstall_t.done=False
566                self.gather_packages_t.done=False
567                self.preactions_process_t.done=False
568                self.update_process_t.done=False
569                self.checkFinalFlavourToInstall_t.done=False
570                self.postactions_process_t.done=False
571               
572                self.initactions_process_t.launched=False
573                self.check_lliurexup_t.launched=False
574                self.install_lliurexup_t.launched=False
575                self.check_mirror_t.launched=False
576                #self.wait_response_t.launched=False
577                self.execute_lliurexmirror_t.launched=False
578                self.get_lliurexversionlocal_t.launched=False
579                self.get_lliurexversionnet_t.launched=False
580                self.checkInitialFlavourToInstall_t.launched=False
581                self.gather_packages_t.launched=False
582                self.preactions_process_t.launched=False
583                self.update_process_t.launched=False
584                self.checkFinalFlavourToInstall_t.launched=False
585                self.postactions_process_t.launched=False
586               
587                self.spinner.start()
588                self.package_list=[]
589                self.max_seconds=5.0
590                self.current_second=0
591                self.number_process=8
592
593                GObject.threads_init()
594                Gtk.main()
595
596        #def start_gui
597       
598        def set_css_info(self):
599       
600                css = """
601
602
603                #WHITE_BACKGROUND {
604                        background-image:-gtk-gradient (linear, left top, left bottom, from (#ffffff),  to (#ffffff));;
605               
606                }
607
608                #BUTTON_LABEL{
609                        color:white;
610                        font: Roboto 10;
611                }
612
613                #DISABLED_BUTTON_OVER{
614                        background-image:-gtk-gradient (linear, left top, left bottom, from (#888888),  to (#888888));;
615                }
616               
617                #DISABLED_BUTTON{
618                        background-image:-gtk-gradient (linear, left top, left bottom, from (#666666),  to (#666666));;
619                }
620               
621                #CANCEL_BUTTON{
622                        background-image:-gtk-gradient (linear, left top, left bottom, from (#D32F2F),  to (#D32F2F));;
623                }
624               
625                #CANCEL_BUTTON_OVER{
626                        background-image:-gtk-gradient (linear, left top, left bottom, from (#F44336),  to (#F44336));;
627                }
628
629                #BUTTON_COLOR {
630                        background-image:-gtk-gradient (linear, left top, left bottom, from (#448AFF),  to (#448AFF));;
631               
632                }
633               
634                #BUTTON_OVER_COLOR {
635                        background-image:-gtk-gradient (linear, left top, left bottom, from (#449fff),  to (#449fff));;
636                       
637               
638                }
639
640                #UPDATE_BUTTON_LABEL{
641                        color:white;
642                        font: Roboto 11;
643                }
644               
645                #UPDATE_CORRECT_BUTTON_COLOR {
646                        background-image:-gtk-gradient (linear, left top, left bottom, from (#979797),  to (#979797));;
647               
648                }
649
650                #UPDATE_OVER_COLOR {
651                        background-image:-gtk-gradient (linear, left top, left bottom, from (#53b757),  to (#53b757));;
652               
653                }
654
655
656                #UPDATE_ERROR_BUTTON_COLOR {
657                        background-image:-gtk-gradient (linear, left top, left bottom, from (#D32F2F),  to (#D32F2F));;
658               
659                }
660
661                #UPDATE_LAUNCHED_OVER_COLOR {
662                        background-image:-gtk-gradient (linear, left top, left bottom, from (#F44336),  to (#F44336));;
663               
664                }
665
666                #UPDATE_BUTTON_LAUNCHED_COLOR {
667                        background-image:-gtk-gradient (linear, left top, left bottom, from (#7cadff), to (#7cadff));;
668
669                }
670                               
671                #GATHER_ICON_COLOR {
672                        background-image:-gtk-gradient (linear, left top, left bottom, from (#b0bec5),  to (#b0bec5));;
673               
674                }
675               
676               
677                #BLUE_FONT {
678                        color: #3366cc;
679                        font: Roboto Bold 11;
680                       
681                }       
682               
683
684                #CHANGELOG_FONT {
685                        color: #3366cc;
686                        font: Roboto 11;
687                       
688                }
689
690                #LABEL_OPTION{
691               
692                        color: #808080;
693                        font: Roboto 11;
694                }
695
696                #ERROR_FONT {
697                        color: #CC0000;
698                        font: Roboto Bold 11;
699                }
700
701                #CORRECT_FONT {
702                        color: #43a047;
703                        font: Roboto Bold 11;
704
705                }
706               
707                #DISABLED_BUTTON{
708                        background-image:-gtk-gradient (linear, left top, left bottom, from (#666666),  to (#666666));;
709                }
710                """
711
712                self.style_provider=Gtk.CssProvider()
713                self.style_provider.load_from_data(css)
714                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
715               
716                self.window.set_name("WHITE_BACKGROUND")
717                self.update_box.set_name("WHITE_BACKGROUND")
718                self.gather_box.set_name("WHITE_BACKGROUND")
719                self.packages_box.set_name("WHITE_BACKGROUND")
720                self.gather_label.set_name("CHANGELOG_FONT")
721                self.pbar_label.set_name("CHANGELOG_FONT")
722
723                self.yes_button_box.set_name("BUTTON_COLOR")
724                self.yes_button_label.set_name("BUTTON_LABEL")
725
726                self.no_button_box.set_name("BUTTON_COLOR")
727                self.no_button_label.set_name("BUTTON_LABEL")
728
729                self.view_packages_button_box.set_name("BUTTON_COLOR")
730                self.view_packages_label.set_name("BUTTON_LABEL")
731
732                self.cancel_button_box.set_name("BUTTON_COLOR")
733                self.cancel_button_label.set_name("BUTTON_LABEL")
734                self.indicator_label.set_name("LABEL_OPTION")   
735
736                self.current_version_label.set_name("LABEL_OPTION")
737                self.version_available_label.set_name("LABEL_OPTION")
738                self.version_update_label.set_name("LABEL_OPTION")     
739                self.number_packages_label.set_name("LABEL_OPTION")
740                self.size_update_label.set_name("LABEL_OPTION")
741                self.update_button_label.set_name("UPDATE_BUTTON_LABEL")
742                self.update_button_box.set_name("BUTTON_COLOR")
743                self.terminal_label.set_name("CHANGELOG_FONT")
744                self.current_version_label_info.set_name("BLUE_FONT")
745                self.version_available_label_info.set_name("BLUE_FONT")
746                self.version_update_label_info.set_name("BLUE_FONT")
747                self.number_packages_label_info.set_name("BLUE_FONT")
748                self.size_update_label_info.set_name("BLUE_FONT")
749
750
751                self.packages_label.set_name("LABEL_OPTION")
752                #self.changelog_label.set_name("LABEL_OPTION")
753                self.changelog_texview.set_name("CHANGELOG_FONT")
754                self.return_arrow_box.set_name("BUTTON_COLOR")
755               
756        #def set_css_info       
757
758
759        def pulsate_checksystem(self):
760
761                #self.pbar.pulse()
762
763                abort=False
764                if not self.initactions_process_t.launched:
765                        print "  [Lliurex-Up]: Checking system: connection to lliurex.net and init-actions"
766                        self.initactions_process_t.start()
767                        self.initactions_process_t.launched=True
768                        self.show_number_process_executing(1,"")
769                # if not self.check_lliurexup_t.launched:
770                #       print "[Lliurex-Up]: Checking Lliurex-up version"
771                #       self.check_lliurexup_t.start()
772                #       self.check_lliurexup_t.launched=True
773                #       self.show_number_process_executing(1,"")
774
775                if self.initactions_process_t.done:
776                        if self.free_space:
777                                if self.statusN4d:
778                                        if self.can_connect:
779                                                #is_mirror_running_inserver=self.llxup_connect.clientCheckingMirrorIsRunning()
780                                                if self.is_mirror_running_inserver==False:
781
782                                                        if  not self.check_lliurexup_t.is_alive() and not self.check_lliurexup_t.launched:
783                                                                print "  [Lliurex-Up]: Checking Lliurex-Up version"
784                                                                msg_gather="<span><b>"+_("Looking for new version of LliureX Up")+"</b></span>"
785                                                                self.gather_label.set_markup(msg_gather)
786                                                                self.check_lliurexup_t.start()
787                                                                self.check_lliurexup_t.launched=True
788                                                                self.show_number_process_executing(2,"")
789
790
791                                                        if  self.check_lliurexup_t.done:
792                                                                if not self.is_lliurexup_updated:
793                                                                        if  not self.install_lliurexup_t.is_alive() and not self.install_lliurexup_t.launched:
794                                                                                print "  [Lliurex-Up]: Updating Lliurex-Up"
795                                                                                msg_gather="<span><b>"+_("Updating LliureX Up")+"</b></span>"
796                                                                                self.gather_label.set_markup(msg_gather)
797                                                                                self.install_lliurexup_t.start()
798                                                                                self.install_lliurexup_t.launched=True
799                                                                                self.show_number_process_executing(3,"")
800
801                                                                        else:
802                                                                                if self.install_lliurexup_t.done:
803                                                                                        print "  [Lliurex-Up]: Reboot Lliurex-Up"
804                                                                                        #msg_gather="<span><b>"+_("Lliurex-up is now updated and will be reboot")+"</b></span>"
805                                                                                        #self.pbar.hide()
806                                                                                        #self.gather_label.set_markup(msg_gather)
807                                                                                        #self.t=threading.Thread(target=self.reboot_lliurexup)
808                                                                                        self.pbar_label.hide()
809                                                                                        self.msg_wait="<span><b>"+_("LliureX Up is now updated and will be reboot in %s seconds...")+"</b></span>"
810                                                                                        GLib.timeout_add(10,self.wait_to_reboot)
811                                                                                        #self.t.daemon=True
812                                                                                        #self.t.start()
813                                                                                        return False
814                                                                else:
815                                                                        if not self.check_mirror_t.is_alive() and not self.check_mirror_t.launched:
816                                                                                print "  [Lliurex-Up]: Checking if mirror exist"
817                                                                                msg_gather="<span><b>"+_("Checking if mirror exist and there is updated")+"</b></span>"
818                                                                                self.gather_label.set_markup(msg_gather)
819                                                                                self.check_mirror_t.start()
820                                                                                self.check_mirror_t.launched=True
821                                                                                self.show_number_process_executing(4,"")
822
823
824                                                                       
825                                                                        if      self.check_mirror_t.done:
826                                                                                is_mirror_running=self.llxup_connect.lliurexMirrorIsRunning()
827
828                                                                                if not self.is_mirror_updated:
829                                                                                        if not is_mirror_running:
830                                                                                                print "  [Lliurex-Up]: Asking if mirror will be update"
831                                                                                                self.yes_button_box.show()
832                                                                                                self.no_button_box.show()
833                                                                                                self.pbar.hide()
834                                                                                                self.pbar_label.hide()
835                                                                                                #self.spinner.stop()
836                                                                                                msg_gather="<span><b>"+_("Your mirror is not update. Do you want to update it?")+"</b></span>"
837                                                                                                self.gather_label.set_markup(msg_gather)
838                                                                                                #GLib.timeout_add(100,self.pulsate_wait_response)
839                                                                                                return False
840
841                                                                                        else:
842                                                                                                self.mirror_running_msg()
843                                                                                                return False
844
845                                                                                else:   
846                                                                                        if is_mirror_running:
847                                                                                                self.mirror_running_msg()
848                                                                                                return False
849                                                                                        else:   
850                                                                                                print "  [Lliurex-Up]: Nothing to do with mirror"
851                                                                                                GLib.timeout_add(100,self.pulsate_get_info)
852                                                                                                return False
853                                       
854                                                else:
855                                                        abort=True
856                                                        '''
857                                                        self.spinner.stop()
858                                                        self.pbar.hide()
859                                                        self.pbar_label.hide()
860                                                        self.cancel_button_box.show()
861                                                        self.gather_label.set_name("ERROR_FONT")
862                                                        '''
863                                                        if self.is_mirror_running_inserver:
864                                                                msg_gather="<span><b>"+_("Mirror is being updated in server. Unable to update the system")+"</b></span>"
865                                                                print "  [Lliurex-Up]: Mirror is being updated in server"
866                                                        else:
867                                                                msg_gather="<span><b>"+_("Unable to connect with server")+"</b></span>"
868                                                                print "  [Lliurex-Up]: Unable to connect with server"
869
870
871                                                        #self.gather_label.set_markup(msg_gather)
872                                                        #return False
873
874
875                                        else:
876                                                abort=True
877                                                '''
878                                                self.spinner.stop()
879                                                self.pbar.hide()
880                                                self.pbar_label.hide()
881                                                self.cancel_button_box.show()
882                                                self.gather_label.set_name("ERROR_FONT")
883                                                '''
884                                                msg_gather="<span><b>"+_("Unable to connect to lliurex.net")+"</b></span>"
885                                                #self.gather_label.set_markup(msg_gather)
886                                                print "  [Lliurex-Up]: Unable to connect to lliurex.net"
887                                                #return False
888
889                                else:
890                                        abort=True
891                                        '''
892                                        self.spinner.stop()
893                                        self.pbar.hide()
894                                        self.pbar_label.hide()
895                                        self.cancel_button_box.show()
896                                        self.gather_label.set_name("ERROR_FONT")
897                                        '''
898                                        msg_gather="<span><b>"+_('N4d is not working. Restart the service and try againg')+"</b></span>"
899                                        #self.gather_label.set_markup(msg_gather)
900                                        print "  [Lliurex-Up]: N4d is not working"
901                                        #return False
902                        else:
903                                abort=True
904                                msg_gather="<span><b>"+_("There's not enough space on disk to upgrade (2 GB needed)")+"</b></span>"
905                                print "  [Lliurex-Up]: Not enough space on disk"
906                                                               
907                if abort:
908                        self.spinner.stop()
909                        self.pbar.hide()
910                        self.pbar_label.hide()
911                        self.cancel_button_box.show()
912                        self.show_indicator_switch()
913                        self.gather_label.set_name("ERROR_FONT")
914                        self.gather_label.set_markup(msg_gather)
915                        return False
916               
917                               
918                if self.initactions_process_t.is_alive():
919                        return True                                     
920
921                if  self.check_lliurexup_t.launched:
922                        if self.check_lliurexup_t.is_alive():
923                                return True
924
925                if self.install_lliurexup_t.launched: 
926                        if self.install_lliurexup_t.is_alive():
927                                return True     
928                                       
929                if self.check_mirror_t.launched:
930                        if self.check_mirror_t.is_alive():
931                                return True
932
933               
934        #def pulsate_checksystem       
935
936        def wait_to_reboot(self):
937
938                csecond=int(self.max_seconds+1-self.current_second)
939                self.gather_label.set_markup(self.msg_wait%csecond)
940                self.pbar.set_fraction(self.current_second/self.max_seconds)
941
942                self.current_second+=0.01
943
944                if self.current_second>=self.max_seconds:
945                        self.llxup_connect.cleanLliurexUpLock()
946                        os.execl(sys.executable, sys.executable, *sys.argv)     
947                        return False
948                else:
949                        return True
950
951        #def wait_to_reboot
952
953       
954        def initActions_process(self):
955                time.sleep(5)
956                self.free_space=self.llxup_connect.free_space_check()
957                if self.free_space:
958                        self.statusN4d=self.llxup_connect.checkInitialN4dStatus()
959                        if self.statusN4d:
960                                self.llxup_connect.checkInitialFlavour()
961                                self.can_connect=self.llxup_connect.canConnectToLliurexNet()
962                                if self.can_connect:
963                                        self.is_mirror_running_inserver=self.llxup_connect.clientCheckingMirrorIsRunning()
964                                        self.llxup_connect.initActionsScript()
965
966                self.initactions_process_t.done=True
967       
968        def check_lliurexup_version(self):
969
970                #time.sleep(5) 
971                self.is_lliurexup_updated=self.llxup_connect.isLliurexUpIsUpdated()
972                self.check_lliurexup_t.done=True
973               
974        #def check_lliurexup_version   
975               
976        def install_lliurexup(self):
977
978                self.is_lliurexup_installed=self.llxup_connect.installLliurexUp()
979                self.install_lliurexup_t.done=True
980
981        #def install_lliurexup 
982
983               
984        def check_mirror(self):
985
986                self.is_mirror_updated=self.llxup_connect.lliurexMirrorIsUpdated()
987                self.check_mirror_t.done=True
988       
989        #def check_mirror       
990
991        def no_button_clicked(self,widget,event):
992               
993                #self.response=0
994                self.pbar.show()
995                self.pbar_label.show() 
996                GLib.timeout_add(100,self.pulsate_get_info)
997                self.yes_button_box.hide()
998                self.no_button_box.hide()
999                log_msg="Update lliurex-mirror: No"
1000                self.llxup_connect.log(log_msg)
1001
1002        #def def no_button_clicked
1003               
1004        def yes_button_clicked(self,widget,event):
1005       
1006                #self.response=1
1007                self.pbar.show()
1008                self.pbar_label.show()
1009                print "[Lliurex-Up]: Updating mirror"
1010                self.updated_percentage(0)
1011                #self.spinner.start()
1012                self.yes_button_box.hide()
1013                self.no_button_box.hide()
1014                #msg_gather="<span><b>"+_("Mirror is being updated. The process may take several minutes")+"</b></span>"
1015                #self.gather_label.set_markup(msg_gather)
1016                self.execute_lliurexmirror_t.start()
1017                self.mirror_running_msg()
1018                #GLib.timeout_add(1000,self.pulsate_updating_mirror)
1019                log_msg="Update lliurex-mirror: Yes"
1020                print log_msg
1021                self.llxup_connect.log(log_msg)
1022
1023        #def yes_button_clicked
1024
1025        def pulsate_updating_mirror(self):
1026
1027                self.is_mirror_running=self.llxup_connect.lliurexMirrorIsRunning()
1028
1029                if self.is_mirror_running or self.execute_lliurexmirror_t.is_alive():
1030                        mirror_percentage=self.llxup_connect.getPercentageLliurexMirror()
1031                        self.updated_percentage(mirror_percentage)
1032                        return True
1033               
1034                else:
1035                        #self.spinner.stop()
1036                        #self.pbar_label.hide()
1037                        GLib.timeout_add(100,self.pulsate_get_info)
1038                        return False   
1039
1040        #def pulsate_updating_mirro             
1041
1042        def execute_lliurexmirror(self):
1043               
1044                commands.getoutput('/usr/sbin/lliurex-mirror-gui')
1045
1046        #def def execute_lliurexmirror 
1047
1048        def mirror_running_msg(self):
1049
1050                self.spinner.start()
1051                msg_gather="<span><b>"+_("Mirror is being updated. The process may take several minutes")+"</b></span>"
1052                self.gather_label.set_markup(msg_gather)
1053                GLib.timeout_add(1000,self.pulsate_updating_mirror)
1054
1055        #def mirror_running_msg
1056
1057
1058        def pulsate_get_info(self):
1059
1060                #self.pbar.pulse()
1061 
1062                if not self.get_lliurexversionlocal_t.launched:
1063                        print "  [Lliurex-Up]: Looking for LliurexVersion from local repository "
1064                        msg_gather="<span><b>"+_("Looking for new version to update")+"</b></span>"
1065                        self.gather_label.set_markup(msg_gather)
1066                        self.get_lliurexversionlocal_t.start()
1067                        self.get_lliurexversionlocal_t.launched=True
1068                        self.show_number_process_executing(5,"")
1069
1070
1071
1072                if self.get_lliurexversionlocal_t.done:
1073                        if not self.get_lliurexversionnet_t.is_alive() and not self.get_lliurexversionnet_t.launched:
1074                                print "  [Lliurex-Up]: Looking for LliurexVersion from Lliurex net"
1075                                msg_gather="<span><b>"+_("Looking for new version available")+"</b></span>"
1076                                self.gather_label.set_markup(msg_gather)
1077                                self.get_lliurexversionnet_t.start()   
1078                                self.get_lliurexversionnet_t.launched=True
1079                                self.show_number_process_executing(6,"")
1080
1081
1082
1083                        if self.get_lliurexversionnet_t.done:
1084
1085                                if not self.checkInitialFlavourToInstall_t.is_alive() and not self.checkInitialFlavourToInstall_t.launched:
1086                                        print "  [Lliurex-Up]: Checking if installation of metapackage is required"
1087                                        msg_gather="<span><b>"+_("Checking if installation of metapackage is required")+"</b></span>"
1088                                        self.gather_label.set_markup(msg_gather)
1089                                        self.checkInitialFlavourToInstall_t.start()
1090                                        self.checkInitialFlavourToInstall_t.launched=True
1091                                        self.show_number_process_executing(7,"")
1092
1093
1094
1095                                if self.checkInitialFlavourToInstall_t.done:
1096
1097                                        if not self.gather_packages_t.is_alive() and not self.gather_packages_t.launched:
1098                                                print "  [Lliurex-Up]: Looking for for new updates"
1099                                                msg_gather="<span><b>"+_("Looking for new updates")+"</b></span>"
1100                                                self.gather_label.set_markup(msg_gather)
1101                                                self.gather_packages_t.start()
1102                                                self.gather_packages_t.launched=True
1103                                                self.show_number_process_executing(8,"")
1104
1105
1106                                        if self.gather_packages_t.done:
1107                                                self.spinner.stop()
1108                                                self.pbar.hide()
1109                                                self.pbar_label.hide()
1110                                                self.cancel_button_box.show()   
1111                                                self.show_indicator_switch()
1112
1113                                                if len(self.packages)==0:
1114                                                                system_update=True
1115
1116                                                                if self.is_flavour_installed!=0:
1117                                                                        system_update=False
1118                                                                else:   
1119
1120                                                                        if self.version_update["candidate"]!=None:
1121
1122                                                                                if self.version_update["installed"]!=self.version_update["candidate"]:
1123                                                                                        system_update=False
1124                                                                                                                       
1125                                                                        else:
1126                                                                                if self.version_update["installed"]!=self.version_available:
1127                                                                                        system_update=False
1128
1129                                                                if not system_update:
1130                                                                                self.gather_label.set_name("ERROR_FONT")
1131                                                                                msg_gather="<span><b>"+_("Updated abort. An error occurred in the search for updates")+"</b></span>"
1132                                                                                self.gather_label.set_markup(msg_gather)
1133                                                                                log_msg="Updated abort. An error occurred in the search for updates"
1134                                                                                self.llxup_connect.log(log_msg)
1135                                                                                print "  [Lliurex-Up]: Error in search for updates"
1136                                                                                return False
1137                                                                else:
1138                                                                        self.show_indicator_switch()
1139                                                                        self.cancel_button_label.set_label(_("Close"))
1140                                                                        msg_gather="<span><b>"+_("Your system is update")+"</b></span>"
1141                                                                        self.gather_label.set_markup(msg_gather)
1142                                                                        log_msg="System update. Nothing to do"
1143                                                                        self.llxup_connect.log(log_msg)
1144                                                                        print "  [Lliurex-Up]: System update. Nothing to do"
1145                                                                        return False
1146                                                                                                       
1147                                                else:
1148                                                        if not self.incorrect_flavours:
1149
1150                                                                print "  [Lliurex-Up]: System nor update"       
1151
1152                                                                #self.requires_installing_metapackage()
1153                                                                self.parse_packages_updated()
1154                                                                self.populate_packages_tv()
1155                                                                self.get_update_summary()
1156                                                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1157                                                                self.stack.set_visible_child_name("update")     
1158                                                                return False
1159                                                        else:
1160                                                                self.gather_label.set_name("ERROR_FONT")
1161                                                                msg_gather="<span><b>"+_("Updated abort for incorrect metapackages detected in update")+"</b></span>"
1162                                                                self.gather_label.set_markup(msg_gather)
1163                                                                #self.pbar.hide()
1164                                                                log_msg="Updated abort for incorrect metapackages detected in update"
1165                                                                self.llxup_connect.log(log_msg)
1166                                                                print "  [Lliurex-Up]: Update abort. Detect incorrect metapackages in new updates"
1167                                                                return False                                                   
1168               
1169
1170                if self.get_lliurexversionlocal_t.launched:
1171                        if self.get_lliurexversionlocal_t.is_alive():
1172                                return True     
1173
1174                if self.get_lliurexversionnet_t.launched:
1175                        if self.get_lliurexversionnet_t.is_alive():
1176                                return True                             
1177
1178                if self.checkInitialFlavourToInstall_t.launched:
1179                        if self.checkInitialFlavourToInstall_t.is_alive():
1180                                return True
1181
1182                if self.gather_packages_t.launched:
1183                        if self.gather_packages_t.is_alive():
1184                                return True
1185
1186        #def pulsate_get_info   
1187
1188        def get_lliurexversionlocal(self):
1189                self.version_update=self.llxup_connect.getLliurexVersionLocal()
1190                self.get_lliurexversionlocal_t.done=True
1191
1192        #def get_lliurexversionlocal
1193       
1194        def get_lliurexversionnet(self):
1195                self.version_available=self.llxup_connect.getLliurexVersionNet()
1196                self.get_lliurexversionnet_t.done=True
1197
1198
1199        #def get_lliurexversionlocal   
1200       
1201        def checkInitialFlavourToInstall(self):
1202                self.is_flavour_installed=0
1203                self.targetMetapackage=self.llxup_connect.targetMetapackage
1204
1205                if self.targetMetapackage == None:
1206                        # self.flavourToInstall=self.llxup_connect.requiresInstallFlavour()
1207                        # if self.flavourToInstall != None:
1208                        #       print self.flavourToInstall
1209                        #       print "  [Lliurex-Up]: Installation of flavour is required"
1210                        #       self.is_flavour_installed=self.llxup_connect.installInitialFlavour(self.flavourToInstall)       
1211                        #       self.checkInitialFlavourToInstall_t.done=True   
1212                        # else:
1213                        print "  [Lliurex-Up]: Installation of metapackage is not required"
1214                        self.checkInitialFlavourToInstall_t.done=True   
1215
1216                else:
1217                        print "  [Lliurex-Up]: Installation of metapackage is required: " +str(self.targetMetapackage)
1218                        self.is_flavour_installed=self.llxup_connect.installInitialFlavour(self.targetMetapackage)     
1219                        self.checkInitialFlavourToInstall_t.done=True                   
1220
1221        #def checkInitialFlavourToInstall(
1222       
1223        def gather_packages(self):
1224
1225                self.packages,self.size_update=self.llxup_connect.getPackagesToUpdate()
1226                self.incorrect_flavours=self.llxup_connect.checkIncorrectFlavours()
1227                self.gather_packages_t.done=True
1228
1229               
1230        #def gather_info
1231
1232
1233        def get_update_summary(self):
1234
1235                #self.version_available=self.llxup_connect.getLliurexVersionNet()
1236                if self.version_update["installed"]==None:
1237                        msg_current_version_info=_("Not available")
1238
1239                else:
1240                        msg_current_version_info=str(self.version_update["installed"])
1241
1242
1243                if self.version_available==None:
1244                        if 'client' in self.llxup_connect.previousFlavours or self.targetMetapackage=='lliurex-meta-client':
1245                                msg_version_available_info=_("Not available for clients")
1246
1247                        else:
1248                                self.version_available_label_info.set_name("ERROR_FONT")
1249                                msg_version_available_info=_("Not available. Check conexion to lliurex.net")
1250
1251                else:
1252                        msg_version_available_info=self.version_available
1253
1254
1255                if self.version_update["candidate"]==None:
1256                        msg_version_update_info=_("Not available")
1257
1258                else:
1259                        msg_version_update_info=self.version_update["candidate"]
1260
1261                self.number_pkg=len(self.packages)
1262                 
1263                self.size_update_label.show()
1264
1265                msg_number_info=str(self.number_pkg)+ " ("  +str(self.newpackages)+ _(" new)")
1266
1267                msg_size=self.size_update
1268
1269               
1270                self.current_version_label_info.set_markup(msg_current_version_info)
1271                self.version_available_label_info.set_markup(msg_version_available_info)
1272                self.version_update_label_info.set_markup(msg_version_update_info)
1273                self.number_packages_label_info.set_markup(msg_number_info)
1274                self.size_update_label_info.set_markup(msg_size)
1275               
1276        #def get_update_summary
1277               
1278        def updated_percentage(self,completed):
1279
1280                percentage=completed/100.0
1281
1282                self.pbar.set_fraction(percentage)
1283               
1284                msg_value=format(completed,'.0f')
1285               
1286                msg_percentage="<span><b>"+msg_value+"%"+"</b></span>"
1287                self.pbar_label.set_markup(msg_percentage)
1288               
1289               
1290        #def updated_percentage
1291               
1292        def show_number_process_executing(self, execprocess, processname):
1293
1294                self.total_process=self.number_process+1.0
1295                self.pbar.set_fraction(execprocess/self.total_process)
1296                if processname =="":
1297                        msg_pbar=_("Executing process: ") + str(execprocess) + _(" of ") + str(self.number_process)
1298                else:
1299                        msg_pbar=_("Executing process: ") + str(execprocess) + _(" of ") + str(self.number_process) + ". " + processname
1300       
1301                msg_pbar="<span><b>"+msg_pbar+"</b></span>" 
1302                self.pbar_label.set_markup(msg_pbar)
1303
1304        #def show_number_process_executing
1305       
1306        def populate_packages_tv(self):
1307               
1308                for package in self.package_list:
1309                        #self.packages_store.append((package.icon,"<span font='Roboto'><b>"+package.name+"</b></span>\n"+"<span font='Roboto' size='small'>"+package.version+"</span>","<span font='Roboto' size='large'><b>"+package.size+"</b></span>",package.installed))
1310                        self.packages_store.append((package.type,package.icon,"<span font='Roboto'><b>"+package.name+"</b></span>\n"+"<span font='Roboto' size='small'>"+package.version+"</span>","<span font='Roboto' size='small'>"+package.size+"</span>", package.installed))
1311                       
1312                #print len(self.packages_store)
1313               
1314        #def populate_packages_tv
1315       
1316        def parse_packages_updated(self):
1317               
1318                self.newpackages=0     
1319                for item in self.packages:
1320                        tmp=item.split(";")
1321                        if len(tmp)>1:
1322                                pack=Package(tmp[3],tmp[0],tmp[1],tmp[2])
1323                                self.package_list.append(pack)
1324                                if tmp[3]==str(None):
1325                                        self.newpackages=int(self.newpackages)+1       
1326
1327        #def parse_simulate_output
1328       
1329        def package_clicked(self,x,y):
1330
1331                default_text="Downloading changelog..."
1332                selection=self.packages_tv.get_selection()
1333                model,iter=selection.get_selected()
1334                self.changelog_textview.get_buffer().set_text("".join(default_text))
1335
1336                #name=self.packages_store.get_value(iter,1)
1337                name=model[iter][2]
1338                name=name[name.find("<b>")+3:name.find("</b>")]
1339                changelog=self.llxup_connect.getPackageChangelog(name)
1340                self.changelog_textview.get_buffer().set_text("".join(changelog))
1341               
1342       
1343        #def package_clicked                   
1344
1345        def upgrade_process(self,widget, event=None):
1346
1347               
1348                self.msg_upgrade_running=_("The update process is running. Wait a moment please")
1349
1350                if not self.preactions_process_t.launched:
1351                        self.number_process=4
1352                        self.pbar.show()
1353                        #self.pbar.pulse()
1354                        self.viewport.show()
1355                        self.terminal_scrolled.show()
1356                        self.terminal_label.show()
1357                        self.msg_terminal=_("Update process details")
1358                        self.terminal_label.set_markup(self.msg_terminal)
1359                        GLib.timeout_add(100,self.dist_upgrade)
1360
1361                        # self.preactions_process_t.start()
1362                        # self.preactions_process_t.launched=True
1363
1364
1365                else:
1366                        if not self.postactions_process_t.done:
1367                                self.terminal_label.set_name("ERROR_FONT")
1368                                self.terminal_label.set_markup(self.msg_upgrade_running)
1369
1370        #def upgrade_process
1371       
1372        def dist_upgrade(self):
1373
1374                if not self.preactions_process_t.launched:
1375                        print "  [Lliurex-Up]: Executing pre-actions"
1376                        self.pbar_label.show()
1377                        self.cancel_button_box.hide()
1378                        self.indicator_box.hide()
1379
1380                        self.preactions_process_t.start()
1381                        self.preactions_process_t.launched=True
1382                        self.show_number_process_executing(1,_("Preparing system to the update"))
1383                        self.update_button_label.set_text(_("Updating"))
1384                        self.update_button_box.set_name("UPDATE_BUTTON_LAUNCHED_COLOR")
1385
1386                else:
1387
1388                        if self.preactions_process_t.done:
1389                                if not self.update_process_t.is_alive() and not self.update_process_t.launched:
1390                                        print "  [Lliurex-Up]: Executing dist-upgrade"
1391                                        self.update_process_t.start()
1392                                        self.update_process_t.launched=True
1393                                        self.show_number_process_executing(2,_("Downloading and installing packages"))
1394
1395                               
1396                                if self.update_process_t.done:
1397                                        if not self.postactions_process_t.is_alive() and not self.postactions_process_t.launched:
1398                                                print "  [Lliurex-Up]: Executing post-actions"
1399                                                self.postactions_process_t.start()
1400                                                self.postactions_process_t.launched=True
1401                                                self.show_number_process_executing(3,_("Ending the update"))
1402                                       
1403                                        if self.postactions_process_t.done:
1404
1405                               
1406                                                if not self.checkFinalFlavourToInstall_t.is_alive() and not self.checkFinalFlavourToInstall_t.launched:
1407                                                        print "  [Lliurex-Up]: Checking Final metapackage"
1408                                                        self.checkFinalFlavourToInstall_t.start()
1409                                                        self.checkFinalFlavourToInstall_t.launched=True
1410                                                        self.show_number_process_executing(4,_("Checking metapackage"))
1411                                                                                                       
1412                                                               
1413                                                if self.checkFinalFlavourToInstall_t.done:                               
1414                                                        self.cancel_button_box.show()
1415                                                        self.show_indicator_switch()
1416                                                        self.cancel_button_label.set_label(_("Close"))
1417                                                        self.pbar.hide()
1418                                                        self.pbar_label.hide()
1419                                                        self.update_installed_icon()
1420                                                               
1421                                                        self.terminal_label.set_name("CHANGELOG_FONT")
1422                                                                               
1423                                                        if not self.llxup_connect.checkErrorDistUpgrade():
1424                                                                self.terminal_label.set_name("CORRECT_FONT")
1425                                                                self.msg_upgrade_running="<span><b>" + _("The system is now update") + "</b></span>"
1426                                                                self.update_button_label.set_text(_("Update successfully"))
1427                                                                self.update_button_box.set_name("UPDATE_CORRECT_BUTTON_COLOR")
1428
1429                                                        else:
1430                                                                self.terminal_label.set_name("ERROR_FONT")
1431                                                                self.msg_upgrade_running="<span><b>" + _("The updated process has ended with errors") + "</b></span>"
1432                                                                self.update_button_label.set_text(_("Update error"))
1433                                                                self.update_button_box.set_name("UPDATE_ERROR_BUTTON_COLOR")
1434                                                                #self.update_button_box.set_name("UPDATE_BUTTON_END_COLOR")
1435                                                                               
1436                                                       
1437                                                        self.terminal_label.set_markup(self.msg_upgrade_running)
1438                                                        return False   
1439       
1440
1441                if self.preactions_process_t.launched:
1442                        if      not self.preactions_process_t.done:
1443                                if not os.path.exists(self.llxup_connect.preactions_token):
1444                                        return True
1445                                else:
1446                                        self.preactions_process_t.done=True
1447                                        return True
1448
1449
1450                if self.update_process_t.launched:
1451                        if      not self.update_process_t.done:
1452                                if not os.path.exists(self.llxup_connect.upgrade_token):
1453                                        return True
1454                                else:
1455                                        self.update_process_t.done=True 
1456                                        return True
1457                                       
1458                if self.postactions_process_t.launched:
1459                        if      not self.postactions_process_t.done:
1460                               
1461                                if not os.path.exists(self.llxup_connect.postactions_token):
1462                                        return True
1463                                else:
1464                                        self.postactions_process_t.done=True
1465                                        return True             
1466
1467               
1468
1469                if self.checkFinalFlavourToInstall_t.launched:
1470                        if not self.checkFinalFlavourToInstall_t.done:
1471                                if not os.path.exists(self.llxup_connect.installflavour_token):
1472                                        return True
1473                                else:
1474                                        self.checkFinalFlavourToInstall_t.done=True     
1475                                        return True                             
1476
1477                       
1478        #def dist_upgrade
1479
1480
1481        def preactions_process(self):
1482
1483                self.command=self.llxup_connect.preActionsScript()
1484                #self.command=self.llxup_connect.preActionsScript() + ' | tee ' + TMP_FILE + ';rm ' + TMP_FILE +'\n'
1485                length=len(self.command)
1486                self.vterminal.feed_child(self.command, length)
1487
1488        #def preactions_process
1489       
1490        def update_process(self):
1491                 
1492                #self.command='apt-get dist-upgrade -sV | tee '+ TMP_FILE + ';rm ' + TMP_FILE +'\n'
1493                self.command=self.llxup_connect.distUpgradeProcess()
1494                length=len(self.command)
1495                self.vterminal.feed_child(self.command, length)
1496
1497        #def update_process             
1498
1499
1500        def postactions_process(self):
1501
1502                self.command=self.llxup_connect.postActionsScript()
1503                #self.command=self.llxup_connect.preActionsScript() + ' | tee ' + TMP_FILE + ';rm ' + TMP_FILE +'\n'
1504                length=len(self.command)
1505                self.vterminal.feed_child(self.command, length)
1506
1507        #def postactions_process
1508
1509       
1510        def checkFinalFlavourToInstall(self):
1511
1512               
1513                time.sleep(5)
1514                self.flavourToInstall=self.llxup_connect.checkFinalFlavour()
1515
1516                if self.flavourToInstall !=None:
1517                        print "  [Lliurex-Up]: Check Final Metapackage: Instalation of metapackage is required"
1518                        self.installFinalFlavour(self.flavourToInstall)
1519                else:
1520                        print "  [Lliurex-Up]: Check Final Metapackage: Nothing to do"
1521                        self.command='exit ' + '\n'
1522                        length=len(self.command)
1523                        self.vterminal.feed_child(self.command, length)
1524                        self.checkFinalFlavourToInstall_t.done=True     
1525       
1526        #def checkFinalFlavourToInstall
1527
1528        def installFinalFlavour(self,flavourToInstall):
1529
1530                self.command=self.llxup_connect.installFinalFlavour(flavourToInstall)
1531                length=len(self.command)
1532                self.vterminal.feed_child(self.command, length)
1533                               
1534        #def installFinalFlavour
1535       
1536       
1537        def view_packages_clicked(self,widget,event):
1538
1539                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1540                self.stack.set_visible_child_name("packages")
1541               
1542        #def view_packages_clicked     
1543       
1544
1545        def arrow_clicked(self,widget,event):
1546       
1547                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
1548                self.stack.set_visible_child_name("update")     
1549               
1550        #def arrow_clicked
1551
1552        def update_installed_icon(self):
1553       
1554                imagok=Gtk.Image()
1555                imagok.set_from_file(DONE_ICON)         
1556                iconok=imagok.get_pixbuf()
1557
1558                imagerr=Gtk.Image()
1559                imagerr.set_from_file(ERROR_ICON)               
1560                iconerr=imagerr.get_pixbuf()
1561                packages_status=self.llxup_connect.getStatusPackage()
1562
1563                for item in self.packages_store:
1564                        name=item[2].split(">")[2]
1565                        name=name.split("<")[0]
1566                        version=item[2].split(">")[5]
1567                        version=version.split("<")[0]
1568                        tmp=str(name)+"_"+str(version)
1569                        if tmp in packages_status:
1570                                item[4]=iconok
1571                        else:
1572                                item[4]=iconerr
1573                       
1574        #def update_installed_icon     
1575
1576        def mouse_over_yes(self,widget,event):
1577
1578                self.yes_button_box.set_name("BUTTON_OVER_COLOR")
1579
1580        #def mouse_over_yes     
1581
1582        def mouse_exit_yes(self,widget,event):
1583
1584                self.yes_button_box.set_name("BUTTON_COLOR")
1585
1586        #def mouse_exit_yes     
1587
1588        def mouse_over_no(self,widget,event):
1589
1590                self.no_button_box.set_name("BUTTON_OVER_COLOR")
1591
1592        #def mouse_over_no     
1593
1594        def mouse_exit_no(self,widget,event):
1595
1596                self.no_button_box.set_name("BUTTON_COLOR")
1597
1598        #def mouse_exit_no     
1599                       
1600        def mouse_over_view_packages(self,widget,event):
1601
1602                self.view_packages_button_box.set_name("BUTTON_OVER_COLOR")     
1603
1604        #def mouse_over_view_packages   
1605
1606        def mouse_exit_view_packages(self,widget,event):
1607
1608                self.view_packages_button_box.set_name("BUTTON_COLOR")
1609
1610        #def mouse_exit_view_packages   
1611                       
1612        def mouse_over_update_button(self,widget,event):
1613
1614                if not self.preactions_process_t.launched and not self.postactions_process_t.done:
1615                        self.update_button_box.set_name("BUTTON_OVER_COLOR")
1616                else:
1617                        if self.preactions_process_t.launched and not self.postactions_process_t.done :
1618                                self.terminal_label.set_name("BLUE_FONT")
1619                                self.terminal_label.set_markup(self.msg_upgrade_running)
1620
1621        #def mouse_over_update_button
1622                       
1623        def mouse_exit_update_button(self,widget,event):
1624
1625                if self.preactions_process_t.launched and not self.postactions_process_t.done:
1626                        self.terminal_label.set_name("CHANGELOG_FONT")
1627                        self.terminal_label.set_markup(self.msg_terminal)
1628                else:
1629                        if not self.preactions_process_t.launched:
1630                                self.update_button_box.set_name("BUTTON_COLOR")
1631
1632        #def mouse_exit_update_button
1633                       
1634        def mouse_over_cancel(self,widget,event):
1635
1636                self.cancel_button_box.set_name("BUTTON_OVER_COLOR")   
1637
1638        #def mouse_over_cancel 
1639
1640        def mouse_exit_cancel(self,widget,event):
1641
1642                self.cancel_button_box.set_name("BUTTON_COLOR") 
1643
1644        #def mouse_exit_cancel
1645
1646        def mouse_over_return_arrow(self,widget,event):
1647
1648                self.return_arrow_box.set_name("BUTTON_OVER_COLOR")     
1649
1650        #def mouse_over_return_arrow   
1651
1652        def mouse_exit_return_arrow(self,widget,event):
1653
1654                self.return_arrow_box.set_name("BUTTON_COLOR")         
1655
1656        #def mouse_exit_return_arrow   
1657
1658        def show_indicator_switch (self):
1659
1660                indicator=True
1661
1662                try:
1663                        if self.targetMetapackage !=None:
1664                                if self.targetMetapackage =='lliurex-meta-client': 
1665                                        indicator=False
1666                        else:
1667                                if 'client' in self.llxup_connect.previousFlavours:
1668                                        indicator=False
1669
1670                        if indicator:           
1671                                self.indicator_box.show()
1672
1673                except Exception as e: 
1674                        self.indicator_box.hide()       
1675
1676        #def show_indicator_switch             
1677
1678        def config_indicator(self):
1679
1680                show_indicator=self.indicator_switch.get_state()
1681               
1682                if show_indicator:
1683                        if os.path.exists(DISABLE_INDICATOR_TOKEN):
1684                                os.remove(DISABLE_INDICATOR_TOKEN)
1685                else:
1686                        if not os.path.exists(DISABLE_INDICATOR_TOKEN):
1687                                if not os.path.exists(DISABLE_INDICATOR_PATH):
1688                                        os.mkdir(DISABLE_INDICATOR_PATH)
1689                       
1690                                f=open(DISABLE_INDICATOR_TOKEN,'w')
1691                                f.close
1692
1693
1694        #def config_indicator                   
1695                               
1696        def quit(self,widget,event=None):
1697
1698                self.llxup_connect.cleanEnvironment()
1699                self.llxup_connect.cleanLliurexUpLock()
1700                self.config_indicator()
1701                Gtk.main_quit() 
1702
1703        #def quit       
1704
1705#class LliurexUp
1706
1707lup=LliurexUp()
1708#lup.start_gui()               
1709 
Note: See TracBrowser for help on using the repository browser.