Changeset 4032 for lliurex-gdrive


Ignore:
Timestamp:
Mar 27, 2017, 10:21:04 AM (3 years ago)
Author:
jrpelegrina
Message:

End fix code to add check connection. Add spinner to indicator

Location:
lliurex-gdrive/trunk/fuentes
Files:
5 added
3 edited

Legend:

Unmodified
Added
Removed
  • lliurex-gdrive/trunk/fuentes/lliurex-gdrive-gui.install/usr/share/lliurex-gdrive/ProfileBox.py

    r4031 r4032  
    3333DELETE_IMAGE=RSRC+"rsrc/trash.svg"
    3434MAX_RETRY_INTENTS=1200
    35 MSG_CHANGE_SUCCESS=_("Changes applied successfully")
    36 MSG_CHANGE_ERROR=_("An error ocurred applying changes. See log file for more information")
    3735
    3836
     
    9593                self.create_mountpoint_t=threading.Thread(target=self.create_mountpoint)
    9694                self.edit_profile_t=threading.Thread(target=self.edit_profile)
    97                 #self.delete_profile_t=threading.Thread(target=self.delete_profile)
    9895                self.check_connection_t=threading.Thread(target=self.check_connection)
    9996               
     
    10299                self.create_mountpoint_t.daemon=True
    103100                self.edit_profile_t.daemon=True
    104                 #self.delete_profile_t.daemon=True
    105101                self.check_connection_t.daemon=True
    106102
    107103                self.create_mountpoint_t.done=False
    108104                self.edit_profile_t.done=False
    109                 #self.delete_profile_t.done=False
    110105
    111106                self.create_profile_t.launched=False
    112107                self.create_mountpoint_t.launched=False
    113108                self.edit_profile_t.launched=False
    114                 #self.delete_profile_t.launched=False
    115109               
    116110                GObject.threads_init()
    117111
     112        #def init_threads       
    118113
    119114        def set_css_info(self):
     
    156151               
    157152                self.profiles_info=info
    158 
     153                print self.profiles_info
    159154                for item in self.profiles_info:
    160155                        profile=item
     
    225220
    226221                self.edition=False
    227 
    228                 self.enable_entry_profile_dialog()
    229                 self.profile_entry.set_text("")
    230                 self.email_entry.set_text("")
    231                 self.mountpoint_entry.set_filename(os.environ["HOME"])
    232                 self.automount_entry.set_active(False)
    233                 self.profile_msg.set_text("")
    234                
    235 
     222                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
     223                self.core.lgd.check_window.show()
    236224                self.init_threads()
    237                
    238                 self.msg_label.set_text("")
    239                 self.profile_msg.hide()
    240                 self.profile_pbar.hide()
    241                 self.init_profile_dialog_button()
    242                 self.new_profile_window.show()
     225                self.check_connection_t.start()
     226                GLib.timeout_add(100,self.pulsate_add_connection)
     227       
     228        def pulsate_add_connection(self):
     229               
     230                if self.check_connection_t.is_alive():
     231                                self.core.lgd.check_pbar.pulse()
     232                                return True
     233
     234                else:
     235                        self.core.lgd.check_window.hide()
     236                        self.enable_entry_profile_dialog()
     237                        #ENCODING TO UNICODE
     238                        if self.connection:
     239                                self.profile_entry.set_text("")
     240                                self.email_entry.set_text("")
     241                                self.mountpoint_entry.set_filename(os.environ["HOME"])
     242                                self.automount_entry.set_active(False)
     243                                self.profile_msg.set_text("")
     244               
     245
     246                                self.init_threads()
     247                               
     248                                self.msg_label.set_text("")
     249                                self.profile_msg.hide()
     250                                self.profile_pbar.hide()
     251                                self.init_profile_dialog_button()
     252                                self.new_profile_window.show()
     253                               
     254                        else:           
     255                                msg_error=self.get_msg(8)
     256                                self.msg_label.set_name("MSG_ERROR_LABEL")
     257                                self.msg_label.set_text(msg_error)             
     258               
     259                return False   
    243260               
    244261
     
    251268                response=dialog.run()
    252269                dialog.destroy()
    253                 #self.delete_profile_t=threading.Thread(target=self.delete_profile))
    254                 #self.init_threads()
     270               
    255271
    256272                if response==Gtk.ResponseType.YES:
     
    271287                        GLib.timeout_add(100,self.pulsate_delete_profile,profile,hbox)
    272288
    273 
    274                         # delete=self.core.LliurexGoogleDriveManager.delete_profile(self.profiles_info,profile)
    275                         # self.msg_label.show()
    276 
    277                         # if delete["result"]:
    278                         #       self.profile_msg.set_name("MSG_LABEL")
    279                         #       self.msg_label.set_text(MSG_CHANGE_SUCCESS)
    280                         #       self.profile_list_box.remove(hbox)
    281                         # else:
    282                         #       msg_error=self.get_msg_error(delete["code"])
    283                         #       self.msg_label.set_name("MSG_ERROR_LABEL")
    284                         #       self.msg_label.set_text(msg_error)
    285 
    286                         # self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()
    287 
    288 
    289289        # def delete_profile_clicked
    290290               
     
    296296
    297297                        else:
    298                                 #delete=self.core.LliurexGoogleDriveManager.delete_profile(self.profiles_info,profile)
    299298                                self.msg_label.show()
    300299                                self.core.lgd.check_window.hide()
    301300                                if self.delete["result"]:
    302301                                        self.msg_label.set_name("MSG_LABEL")
    303                                         self.msg_label.set_text(MSG_CHANGE_SUCCESS)
    304302                                        self.profile_list_box.remove(hbox)
    305303                                else:
    306                                         msg_error=self.get_msg_error(self.delete["code"])
    307304                                        self.msg_label.set_name("MSG_ERROR_LABEL")
    308                                         self.msg_label.set_text(msg_error)
     305                               
     306                                msg_text=self.get_msg(self.delete["code"])
     307                                self.msg_label.set_text(msg_text)
    309308                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()
    310        
     309                               
    311310                        return False   
    312311
     
    315314
    316315                self.delete=self.core.LliurexGoogleDriveManager.delete_profile(self.profiles_info,profile)
    317                 #self.delete_profile_t.done=True                                       
    318316
    319317        def sync_profile_clicked(self,button,hbox):
     
    329327                GLib.timeout_add(100,self.pulsate_sync_profile,button,hbox)
    330328
    331 
    332                 # profile=hbox.get_children()[1].get_text().split("\n")[0]
    333                 # mountpoint=hbox.get_children()[3].get_text()
    334                 # # ENCODING TO UNICODE         
    335                 # profile=profile.decode("utf-8")
    336                 # mountpoint=mountpoint.decode("utf-8")
    337                 # status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
    338                 # self.msg_label.show()
    339                 # self.msg_label.set_name("MSG_LABEL")
    340                 # if self.current_status[profile]==status_info["status"]:
    341 
    342                 #       status_mod=self.core.LliurexGoogleDriveManager.sync_profile(profile,mountpoint)
    343                 #       if status_mod["result"]:
    344                 #               status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
    345                 #               self.msg_label.set_text(MSG_CHANGE_SUCCESS)
    346                                
    347                 #       else:
    348                 #               msg_error=self.get_msg_error(status_mod["code"])
    349                 #               self.msg_label.set_name("MSG_ERROR_LABEL")
    350                 #               self.msg_label.set_text(msg_error)     
    351                                
    352                        
    353 
    354                 # info=self.item_status_info(status_info)
    355                 # self.current_status[profile]=status_info["status"]
    356                 # button.set_tooltip_text(info["tooltip"])
    357                 # button.set_name(info["css"])         
    358                 # hbox.get_children()[4].set_image(info["img"])
    359 
    360329       
    361330        #def sync_profile_cicked
     
    370339                        self.core.lgd.check_window.hide()
    371340                        if self.status_mod["result"]:
    372                                 #status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
    373                                 self.msg_label.set_text(MSG_CHANGE_SUCCESS)
     341                                msg_text=self.get_msg(self.status_mod["code"])
     342                                self.msg_label.set_name("MSG_LABEL")
     343                                self.msg_label.set_text(msg_text)
    374344                               
    375345                        else:
    376                                 msg_error=self.get_msg_error(self.status_mod["code"])
     346                                msg_text=self.get_msg(self.status_mod["code"])
    377347                                self.msg_label.set_name("MSG_ERROR_LABEL")
    378                                 self.msg_label.set_text(msg_error)     
    379                        
    380 
    381                         info=self.item_status_info(self.status_info)
     348                                self.msg_label.set_text(msg_text)       
     349                       
     350
     351                        info=self.item_status_info(self.status_info['status'])
    382352                        profile=hbox.get_children()[1].get_text().split("\n")[0]
    383                         self.current_status[profile]=self.status_info["status"]
     353                        self.current_status[profile.decode("utf-8")]=self.status_info["status"]
    384354                        button.set_tooltip_text(info["tooltip"])
    385355                        button.set_name(info["css"])           
     
    396366                profile=profile.decode("utf-8")
    397367                mountpoint=mountpoint.decode("utf-8")
    398                
    399                 connect=self.core.LliurexGoogleDriveManager.check_google_connection()
    400 
    401                 if connect:
    402                          self.status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
    403                          if self.current_status[profile]==self.status_info["status"]:
    404                                 self.status_mod=self.core.LliurexGoogleDriveManager.sync_profile(profile,mountpoint)   
    405                                 if self.status_mod["result"]:
    406                                         self.status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)       
    407                                                                
    408                 else:
    409                         self.status_mod={}
    410                         self.status_mod["result"]=False
    411                         self.status_mod["code"]=8                       
     368                connect=True
     369                current_status=self.current_status[profile]
     370                self.status_mod,self.status_info=self.core.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
     371               
    412372
    413373        def edit_profile_clicked(self,button,hbox):
     
    418378                self.init_threads()
    419379                self.check_connection_t.start()
    420                 GLib.timeout_add(100,self.pulsate_connection,hbox)
    421 
    422 
    423                 # self.enable_entry_profile_dialog()
    424                 # #ENCODING TO UNICODE
    425 
    426                 # self.profile_to_edit=hbox             
    427                 # profile=self.profile_to_edit.get_children()[1].get_text().split("\n")[0]
    428                 # self.profile_entry.set_text(profile)
    429                 # email=self.profile_to_edit.get_children()[1].get_text().split("\n")[1]
    430                 # self.email_entry.set_text(email)
    431                 # mountpoint=self.profile_to_edit.get_children()[3].get_text()
    432                 # self.mountpoint_entry.set_filename(mountpoint)
    433                 # automount=self.profiles_info[profile.decode("utf-8")]["automount"]
    434                 # self.automount_entry.set_active(automount)
    435                
    436 
    437                 # self.init_threads()
    438 
    439                 # self.profile_msg.hide()
    440                 # self.profile_pbar.hide()
    441                 # self.msg_label.set_text("")
    442                 # self.init_profile_dialog_button()
    443                 # self.new_profile_window.show()       
    444 
     380                GLib.timeout_add(100,self.pulsate_edit_connection,hbox)
     381
     382               
    445383        #def edit_profile_clicked
    446384
    447         def pulsate_connection(self,hbox):
     385        def pulsate_edit_connection(self,hbox):
    448386
    449387                if self.check_connection_t.is_alive():
     
    476414
    477415                        else:           
    478                                 msg_error=self.get_msg_error(8)
     416                                msg_text=self.get_msg(8)
    479417                                self.msg_label.set_name("MSG_ERROR_LABEL")
    480                                 self.msg_label.set_text(msg_error)             
     418                                self.msg_label.set_text(msg_text)               
    481419                return False
    482420
     
    534472                        status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
    535473                        self.current_status[profile_name]=status_info["status"]
    536                         info=self.item_status_info(status_info)
     474                        info=self.item_status_info(status_info["status"])
    537475                else:
    538                         info={}
    539                         img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
    540                         info["img"]=img
    541                         info["css"]="WARNING_ITEM_BUTTON"
    542                         info["tooltip"]=_("With out connect")   
     476                        info=self.item_status_info(None)
     477                        self.current_status[profile_name]=None
     478                       
    543479               
    544480                mount_image=info["img"]
     
    567503        def item_status_info(self,status_info):
    568504       
    569                 size=status_info["size"]
    570                 used=status_info["used%"]
    571 
    572                 if status_info["status"]:
     505               
     506
     507                if status_info==None:
     508                        print "SIN ESTADO"
    573509                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
    574                         tooltip=_("Dismount now")
     510                        css="WARNING_ITEM_BUTTON"
     511                        tooltip=_("Without connection. Clicked to update")
     512                        css="WARNING_ITEM_BUTTON"                       
     513                elif status_info:
     514                        print "CON ESTADO"
     515                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
     516                        tooltip=_("Mounted. Clicked to dismount now")
    575517                        css="MOUNT_ITEM_BUTTON"
    576                
    577518                else:
    578519                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
    579                         tooltip=_("Mount now")
     520                        tooltip=_("Dismounted. Clicked to mount now")
    580521                        css="DELETE_ITEM_BUTTON"       
    581522
     
    680621                                               
    681622                                else:
    682                                         msg_error=self.get_msg_error(self.create_result["code"])
     623                                        msg_text=self.get_msg(self.create_result["code"])
    683624                                        self.profile_msg.set_name("MSG_ERROR_LABEL")
    684                                         self.profile_msg.set_text(msg_error)
     625                                        self.profile_msg.set_text(msg_text)
    685626                                        self.cancel_add_profile_button.show()
    686627                                       
     
    701642
    702643
    703         def get_msg_error(self,code):
    704 
    705                 if code==1:
    706                         msg_error=_("Error: Unable to create mount point")
     644        def get_msg(self,code):
     645
     646                if      code==0:
     647                        msg_text=_("Changes applied successfully")
     648               
     649                elif    code==1:
     650                        msg_text=_("Error: Unable to create mount point")
    707651
    708652                elif code==2:
    709                         msg_error=_("Error: unable to mount mount point")
     653                        msg_text=_("Error: unable to mount mount point")
    710654
    711655                elif code==3:
    712                         msg_error=_("Error: Mount point is not owned by user") 
     656                        msg_text=_("Error: Mount point is not owned by user")   
    713657
    714658                elif code==4:
    715                         msg_error=_("Error: No mount point indicated")
     659                        msg_text=_("Error: No mount point indicated")
    716660
    717661                elif code==5:
    718                         msg_error=_("Error: Profile is not authorized to Google Drive")
     662                        msg_text=_("Error: Profile is not authorized to Google Drive")
    719663
    720664                elif code==6:
    721                         msg_error=_("Error: Unknow profile")
     665                        msg_text=_("Error: Unknow profile")
    722666
    723667                elif code==7:
    724                         msg_error=_("Error: Unable to dismount mount point")
     668                        msg_text=_("Error: Unable to dismount mount point")
    725669
    726670                elif code==8:
    727                         msg_error=_("Error: Unable to connect with google")                     
    728 
    729                 return msg_error       
    730 
    731         #def get_msg_error                                                     
     671                        msg_text=_("Error: Unable to connect with google")     
     672                       
     673                elif code==9:
     674                        msg_text=_("Status updated. Now you can change it")
     675                return msg_text
     676
     677        #def get_msg                                                   
    732678
    733679        def kill_create_profile(self):
     
    773719                                self.profile_to_edit.get_children()[3].set_text(self.new_mountpoint)
    774720                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
    775                                 self.profile_msg.set_text(MSG_CHANGE_SUCCESS)
    776721                                self.change_cancel_button()
    777722                       
    778723                        else:
    779                                 msg_error=self.get_msg_error(self.edit_result["code"])
     724                               
    780725                                self.profile_msg.set_name("MSG_ERROR_LABEL")
    781                                 self.profile_msg.set_text(msg_error)
    782726                                self.cancel_add_profile_button.show()
     727
     728                        msg_text=self.get_msg(self.edit_result["code"])
     729                        self.profile_msg.set_text(msg_text)
     730
    783731                        return False
    784732                       
  • lliurex-gdrive/trunk/fuentes/lliurex-gdrive-indicator.install/usr/bin/lliurexGdriveIndicator

    r4029 r4032  
    3535MOUNT_OFF_IMAGE=RSRC+"rsrc/mount_off.png"
    3636MOUNT_WARNING_IMAGE=RSRC+"rsrc/mount_warning.png"
    37 
    38 TIME_CHECK_STATUS=300000
     37SP1=RSRC+"rsrc/sp1.png"
     38SP2=RSRC+"rsrc/sp2.png"
     39SP3=RSRC+"rsrc/sp3.png"
     40SP4=RSRC+"rsrc/sp4.png"
     41
     42TIME_CHECK_STATUS=60000
    3943
    4044class LlliurexGdriveIndicator:
     
    6064                self.populate_menu()
    6165                self.start_inotify()
    62                 self.connect_threads={}
    63                 self.result_connect_threads={}
     66                self.sync_threads={}
     67                self.result_sync_threads={}
    6468                self.profile_clicked=[]
     69                self.sp_cont={}
     70                self.sp_img={}
    6571                self.checking_status=False
    6672               
     
    7581                return
    7682
    77         def generate_threads(self):
     83        def generate_sync_threads(self,profile):
    7884               
    7985                id=int(random.random()*1000)           
    80                 t=threading.Thread(target=self.check_connection,args=(id,))
     86                t=threading.Thread(target=self.check_sync,args=(id,profile))
    8187                t.daemon=True
    8288                t.start()
    83                 self.connect_threads[id]={}
    84                 self.connect_threads[id]["thread"]=t
    85                 self.result_connect_threads[id]={}
     89                self.sync_threads[id]={}
     90                self.sync_threads[id]["thread"]=t
     91                self.result_sync_threads[id]={}
    8692                return id
    87 
     93       
     94        def init_connect_thread(self):
     95               
     96                self.check_connect_t=threading.Thread(target=self.check_connect)
     97                self.check_connect_t.daemon=True
     98                self.check_connect_t.start()
     99               
    88100        def createLockToken(self):
    89101
     
    171183                        self.current_status[profile]=status_info["status"]     
    172184                else:
    173                         info={}
    174                         img=Gtk.Image.new_from_file(MOUNT_WARNING_IMAGE)
    175                         tooltip=_("With out connect")
    176                         used_size=_("Used: not available")
    177                         info["img"]=img
    178                         info["tooltip"]=tooltip
    179                         info["used_size"]=used_size
    180                        
    181                        
     185                        status_info={}
     186                        status_info['status']=None
     187                        status_info['size']=0
     188                        status_info['used']=0
     189                        info=self.item_status_info(status_info)
     190                        self.current_status[profile]=None
     191                               
    182192                label_item=profile     
    183193                item=Gtk.ImageMenuItem()
     
    269279                if profile not in self.profile_clicked:
    270280                        self.profile_clicked.append(profile)
    271                         id=self.generate_threads()
    272                         GLib.timeout_add(100,self.pulsate_check_connection,id,widget,profile)
    273 
     281                        id=self.generate_sync_threads(profile)
     282                        self.sp_cont[id]=0
     283                        self.sp_img[id]=Gtk.Image.new_from_file(SP1)
     284                        GLib.timeout_add(100,self.pulsate_check_sync,id,widget,profile)
     285                       
    274286               
    275287        #def item_clicked
    276288
    277         def pulsate_check_connection(self,id,widget,profile):
    278                
    279                
    280                 if self.connect_threads[id]["thread"].is_alive():
     289        def spinner_sync(self,id):
     290       
     291                if self.sp_cont[id]>40:
     292                        self.sp_cont[id]=0
     293                       
     294                if self.sp_cont[id]==0:
     295                        img=Gtk.Image.new_from_file(SP1)
     296                        self.sp_img[id]=img
     297                elif self.sp_cont[id]==10:
     298                        img=Gtk.Image.new_from_file(SP2)
     299                        self.sp_img[id]=img                     
     300                elif self.sp_cont[id]==20:
     301                        img=Gtk.Image.new_from_file(SP3)
     302                        self.sp_img[id]=img
     303                elif self.sp_cont[id]==30:
     304                        img=Gtk.Image.new_from_file(SP4)
     305                        self.sp_img[id]=img
     306                               
     307               
     308                       
     309        def pulsate_check_sync(self,id,widget,profile):
     310               
     311               
     312                if self.sync_threads[id]["thread"].is_alive():
     313                        self.spinner_sync(id)
     314                        widget.set_image(self.sp_img[id])
     315                        widget.set_tooltip_text(_("Applying changes..."))       
     316                        self.sp_cont[id]=self.sp_cont[id]+1
    281317                        return True
    282318               
    283319                else:
    284320                        self.profile_clicked.remove(profile)
    285                         if self.result_connect_threads[id]["value"]:
    286                                 self.connect_threads.pop(id)
    287                                 self.result_connect_threads.pop(id)
    288                                 mountpoint=self.profiles_info[profile]["mountpoint"]
    289                                 status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
    290                                
    291                                 if self.current_status[profile]==status_info["status"]:
    292                                         status_mod=self.LliurexGoogleDriveManager.sync_profile(profile,mountpoint)
    293 
    294                                         if status_mod["result"]:
    295                                                 status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
     321                        self.current_status[profile]=self.result_sync_threads[id]["status_info"]["status"]     
     322                        if self.result_sync_threads[id]["status_mod"]["result"]==False:
     323                                if self.result_sync_threads[id]["status_mod"]["code"]==8:
     324                                        message=profile + _("Error: Unable to connect with google")     
     325                                else:
     326                                        status=self.current_status[profile]
     327                                        if status:
     328                                                action=_("dismount")
     329                                        else:
     330                                                action=_("mount")       
     331                                        message=_("Error: Unable to ") + action + " "
     332                        else:
     333                                if self.result_sync_threads[id]["status_mod"]["code"]==9:
     334                                        message=_("Status updated. Now you can change it")
     335                                else:
     336                                        message=_("Changes applied successfully")
     337                       
     338                        self.show_message(profile + ". " + message)
     339                       
     340                        info=self.item_status_info(self.result_sync_threads[id]["status_info"])
     341                       
     342                        for item in self.menu.get_children():
     343                                        if item.size:
     344                                                if item.profile==profile:
     345                                                        item.set_label(info["used_size"])
     346                               
     347                        widget.set_tooltip_text(info["tooltip"])
     348                        widget.set_image(info["img"])   
     349                        self.sync_threads.pop(id)
     350                        self.sp_cont.pop(id)
     351                        self.sp_img.pop(id)
     352                        self.result_sync_threads.pop(id)
     353               
     354                return False
     355                       
     356       
     357        def     check_sync(self,id,profile):
     358               
     359                mountpoint=self.profiles_info[profile]["mountpoint"]
     360
     361                current_status=self.current_status[profile]
     362               
     363                self.result_sync_threads[id]["status_mod"],self.result_sync_threads[id]["status_info"]=self.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
     364
     365
     366                #self.result_connect_threads[id]["value"]=self.LliurexGoogleDriveManager.check_google_connection()
     367       
     368        def open_folder(self,widget,profile):
     369
     370               
     371                mountpoint=self.profiles_info[profile]["mountpoint"]
     372                cmd="caja " + mountpoint.encode("utf-8")
     373
     374                os.system(cmd) 
     375
     376        #def open_folder       
     377
     378        def open_gui(self,widget):
     379               
     380                if not os.path.exists(LOCK_GUI):
     381                        cmd='/usr/bin/lliurex-gdrive' +"&"
     382                        os.system(cmd)
     383
     384        #def open_gui
     385               
     386        def item_status_info(self,status_info):
     387       
     388                size=status_info["size"]
     389                used=status_info["used"]
     390
     391                if status_info['status']==None:
     392                        img=Gtk.Image.new_from_file(MOUNT_WARNING_IMAGE)
     393                        tooltip=_("Without connection. Clicked to update")
     394                        used_size=_("Used: not available")
     395               
     396                elif    status_info["status"]:
     397                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
     398                        tooltip=_("Mounted. Clicked to dismount now")
     399                        used_size=_("Used: %s of %s")%(used,size)
     400               
     401                else:
     402                        img=Gtk.Image.new_from_file(MOUNT_OFF_IMAGE)
     403                        tooltip=_("Dismounted. Clicked to mount now")
     404                        used_size=_("Used: not available")     
     405
     406                return {"img":img ,"tooltip":tooltip, "used_size":used_size}   
     407
     408        #def item_status_info                   
     409
     410        def check_status(self):
     411               
     412                if not self.checking_status:
     413                        self.checking_status=True
     414                        self.init_connect_thread()
     415                        GLib.timeout_add(100,self.get_status_info,id)
     416
     417                return True
     418               
     419               
     420        #def check_status
     421       
     422        def get_status_info(self,id):
     423               
     424                if self.check_connect_t.is_alive():
     425                        return True
     426               
     427                else:   
     428                        self.checking_status=False
     429                        #self.connect_threads.pop(id)
     430                        for profile in self.profiles_info:
     431                                if self.connection:
     432                                        mountpoint=self.profiles_info[profile]["mountpoint"]
     433                                        status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
     434                                else:
     435                                        status_info={}
     436                                        status_info['status']=None
     437                                        status_info['size']=0
     438                                        status_info['used']=0
    296439                                       
    297440                                info=self.item_status_info(status_info)
    298441                                self.current_status[profile]=status_info["status"]
    299                        
    300                                 for item in self.menu.get_children():
    301                                         if item.size:
    302                                                 if item.profile==profile:
    303                                                         item.set_label(info["used_size"])
    304                         else:
    305                                 info={}
    306                                 info["tooltip"]=_("With out connect")
    307                                 info["used_size"]=_("Used: not available")
    308                                 img=Gtk.Image.new_from_file(MOUNT_WARNING_IMAGE)
    309                                 info["img"]=img
    310                                 for item in self.menu.get_children():
    311                                         if item.size:
    312                                                 if item.profile==profile:
    313                                                         item.set_label(info["used_size"])
    314                                 status=self.current_status[profile]
    315                                 if status:
    316                                         action=_("dismount")
    317                                 else:
    318                                         action=_("mount")       
    319                                 message=_("Unable to ") + action + " " + profile.encode("utf-8")
    320                                 self.show_message(message)
    321 
    322 
    323                         widget.set_tooltip_text(info["tooltip"])
    324                         widget.set_image(info["img"])   
    325                
    326                 return False
    327                        
    328        
    329         def     check_connection(self,id):
    330 
    331                 self.result_connect_threads[id]["value"]=self.LliurexGoogleDriveManager.check_google_connection()
    332        
    333         def open_folder(self,widget,profile):
    334 
    335                
    336                 mountpoint=self.profiles_info[profile]["mountpoint"]
    337                 cmd="caja " + mountpoint.encode("utf-8")
    338 
    339                 os.system(cmd) 
    340 
    341         #def open_folder       
    342 
    343         def open_gui(self,widget):
    344                
    345                 if not os.path.exists(LOCK_GUI):
    346                         cmd='/usr/bin/lliurex-gdrive' +"&"
    347                         os.system(cmd)
    348 
    349         #def open_gui
    350                
    351         def item_status_info(self,status_info):
    352        
    353                 size=status_info["size"]
    354                 used=status_info["used"]
    355 
    356                 if status_info["status"]:
    357                         img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
    358                         tooltip=_("Dismount now")
    359                         used_size=_("Used: %s of %s")%(used,size)
    360                
    361                 else:
    362                         img=Gtk.Image.new_from_file(MOUNT_OFF_IMAGE)
    363                         tooltip=_("Mount now")
    364                         used_size=_("Used: not available")     
    365 
    366                 return {"img":img ,"tooltip":tooltip, "used_size":used_size}   
    367 
    368         #def item_status_info                   
    369 
    370         def check_status(self):
    371                
    372                 if not self.checking_status:
    373                         self.checking_status=True
    374                         id=self.generate_threads()
    375                         GLib.timeout_add(100,self.get_status_info,id)
    376 
    377                 return True
    378                
    379                
    380         #def check_status
    381        
    382         def get_status_info(self,id):
    383                
    384                 if self.connect_threads[id]["thread"].is_alive():
    385                         return True
    386                
    387                 else:   
    388                         self.checking_status=False
    389                         self.connect_threads.pop(id)
    390                         if self.result_connect_threads[id]["value"]:
    391                                 for profile in self.profiles_info:
    392                                         mountpoint=self.profiles_info[profile]["mountpoint"]
    393                                         status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
    394                                         info=self.item_status_info(status_info)
    395                                         self.current_status[profile]=status_info["status"]
     442                                                               
    396443                                for item in self.menu.get_children():
    397444                                        if item.profile==profile:
     
    401448                                                        item.set_tooltip_text(info["tooltip"])
    402449                                                        item.set_image(info["img"])
    403 
    404 
    405                         else:
    406                                 info={}
    407                                 img["tooltip"]=_("With out connect")
    408                                 img["used_size"]=_("Used: not available")
    409                                                        
    410                                 for profile in self.profiles_info:
    411                                         img=Gtk.Image.new_from_file(MOUNT_OFF_IMAGE)
    412                                         img["img"]=img
    413                                         for item in self.menu.get_children():
    414                                                 if item.profile==profile:
    415                                                         if item.size:
    416                                                                 item.set_label(info["used_size"])
    417                                                         if item.status:
    418                                                                 item.set_tooltip_text(info["tooltip"])
    419                                                                 item.set_image(info["img"])     
    420                        
    421                
    422                 self.result_connect_threads.pop(id)             
     450               
     451                #self.result_connect_threads.pop(id)           
    423452                return False   
    424453                                       
     454        def check_connect(self):
     455               
     456                self.connection=self.LliurexGoogleDriveManager.check_google_connection()
     457
    425458       
    426459        def show_message(self,message):
  • lliurex-gdrive/trunk/fuentes/python-lliurex-gdrive/lliurex/lliurexgdrive/__init__.py

    r4031 r4032  
    107107
    108108                try:
    109                         print "vamos a ver"
    110109                        req=urllib2.Request("http://google.com")
    111110                        res=urllib2.urlopen(req)
     
    225224        #def save_profiles     
    226225
    227         def check_mountpoint_status(self,mountpoint):
     226        def check_mountpoint_status(self,mountpoint,arg=None):
    228227
    229228                mountpoint_size=""
     
    232231                mountpoint_per=""
    233232                tmp=[]
    234 
    235 
    236                 command='df -h | grep "google-drive-ocamlfuse" | grep ' +mountpoint+'$'
    237                        
    238                 p=subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
    239                 poutput,perror=p.communicate()
    240 
    241                 if len(poutput)>0:
    242                         status=True
    243 
    244                         for item in poutput.split(" "):
    245                                 if len(item)>1:
    246                                         tmp.append(item)
    247 
    248                         mountpoint_size=tmp[1]
    249                         mountpoint_used=tmp[2]
    250                         mountpoint_available=tmp[3]
    251                         mountpoint_per=tmp[4]
    252 
     233                connect=True
     234               
     235                if arg!=None:
     236                        print "COMPROBANDO RED"
     237                        connect=self.check_google_connection()
     238               
     239                if connect:
     240                        command='df -h | grep "google-drive-ocamlfuse" | grep ' +mountpoint+'$'
     241                               
     242                        p=subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
     243                        poutput,perror=p.communicate()
     244
     245                        if len(poutput)>0:
     246                                status=True
     247
     248                                for item in poutput.split(" "):
     249                                        if len(item)>1:
     250                                                tmp.append(item)
     251
     252                                mountpoint_size=tmp[1]
     253                                mountpoint_used=tmp[2]
     254                                mountpoint_available=tmp[3]
     255                                mountpoint_per=tmp[4]
     256
     257                        else:
     258                                status=False
    253259                else:
    254                         status=False
    255                
     260                        status=None
     261                                       
    256262                return {"status":status,"size":mountpoint_size,"used":mountpoint_used,"available":mountpoint_available,"used%":mountpoint_per}         
    257263               
     
    303309                if not self.check_config(profile):
    304310                        os.system("google-drive-ocamlfuse -label %s"%unicode(profile).encode("utf-8"))
    305                         msg_log=("'%s' profile has been create")%profile
     311                        msg_log=("'%s' profile has been create")%profile.encode("utf-8")
    306312                        self.log(msg_log)
    307313                        self.dprint(msg_log)
     
    360366        def delete_profile(self,info,profile):
    361367
     368                result={}
    362369                dismount={}
    363370                dismount["result"]=True
     371                dismount["code"]=0
    364372
    365373                connect=self.check_google_connection()
    366374                #profile=str(profile)
    367                 if connect:
    368                         mountpoint=self.profiles_config[profile]["mountpoint"]
    369                        
    370 
    371 
    372                         if os.path.exists(GDRIVE_CONFIG_DIR+profile):
    373                                 is_mountpoint_mounted=self.check_mountpoint_status(mountpoint)
    374 
    375                                 if is_mountpoint_mounted["status"]:
     375                #if connect:
     376                mountpoint=self.profiles_config[profile]["mountpoint"]
     377                       
     378                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
     379                        is_mountpoint_mounted=self.check_mountpoint_status(mountpoint,True)
     380
     381                        if is_mountpoint_mounted["status"]==None:
     382                                print "SIN RED"
     383                                result['result']=False
     384                                result['code']=8
     385                        else:
     386                                if is_mountpoint_mounted["status"]:     
    376387                                        dismount=self.dismount_mountpoint(mountpoint)
    377388
     
    383394                                                self.dprint(msg_log)
    384395                                        self.save_profiles(info)
    385                                         return dismount                 
    386 
    387                         else:
    388                                 self.save_profiles(info)
    389                                 msg_log="Delete profile: '%s' GDrive profile path does not exist"%profile.encode("utf-8")
    390                                 self.log(msg_log)
    391                                 self.dprint(msg_log)
    392                                 return {"result":True,"code":0}
     396                               
     397                                return dismount
     398                               
     399
    393400                else:
    394                         return {"result":False,"code":8}
    395                        
     401                        self.save_profiles(info)
     402                        msg_log="Delete profile: '%s' GDrive profile path does not exist"%profile.encode("utf-8")
     403                        self.log(msg_log)
     404                        self.dprint(msg_log)
     405                        result['result']=True
     406                        result['code']=0
     407               
     408                return result
     409               
    396410               
    397411       
     
    418432                                if result["result"]:
    419433                                        result=self.mount_drive(profile,new_mountpoint)
    420                                        
    421                                        
     434                               
    422435
    423436                if result["result"]:
     
    432445        #def edit_profile                       
    433446
    434         def sync_profile(self,profile,mountpoint):
    435 
    436                 status=self.check_mountpoint_status(mountpoint)
    437 
    438                 if status["status"]:
    439                         action="Dismount"
    440                         result=self.dismount_mountpoint(mountpoint)
     447        def sync_profile(self,profile,mountpoint,current_status):
     448               
     449                result={}
     450                status=self.check_mountpoint_status(mountpoint,True)
     451                print status
     452       
     453                if status["status"]==None:
     454                        result['result']=False
     455                        result['code']=8
    441456                       
    442457                else:
    443                         action="Mount"
    444                         result=self.mount_drive(profile,mountpoint)
    445 
    446                 return {"action":action,"result":result["result"],"code":result["code"]}       
     458                        if current_status!=None and status['status']==current_status:
     459                                if status['status']:
     460                                        result=self.dismount_mountpoint(mountpoint)
     461                                else:
     462                                        result=self.mount_drive(profile,mountpoint)
     463                       
     464                        else:
     465                                result['result']=True
     466                                result['code']=9
     467                               
     468                        status=self.check_mountpoint_status(mountpoint)
     469               
     470                print result
     471                return result,status           
     472                #result["result"]:result["result"]
     473                #result["code"]:result["code"]
     474                #return {"result":result["result"],"code":result["code"]}       
    447475
    448476        #def_sync_profile       
Note: See TracChangeset for help on using the changeset viewer.