Changeset 6436 for lliurex-gdrive


Ignore:
Timestamp:
Dec 7, 2017, 2:48:48 PM (23 months ago)
Author:
jrpelegrina
Message:

Fix files

Location:
lliurex-gdrive/trunk/WIP_files
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • lliurex-gdrive/trunk/WIP_files/__init__.py

    r6432 r6436  
    597597                result={}
    598598                status=self.check_mountpoint_status(mountpoint,True)
    599                 token=profile + "__mountToken"
    600                 token_path=os.path.join(self.config_dir,token)
     599                token_mount=profile + "__MountToken"
     600                token_mount_path=os.path.join(self.config_dir,token_mount)
     601                token_dismount=profile + "__DismountToken"
     602                token_dismount_path=os.path.join(self.config_dir,token_dismount)
     603
    601604       
    602605                if status["status"]==None:
     
    608611                                if status['status']:
    609612                                        result=self.dismount_mountpoint(mountpoint,profile)
    610                                         if os.path.exists(token_path):
    611                                                 f=open(token_path,'w')
    612                                                 f.close()
    613                                                 os.remove(token_path)
     613                                        f=open(token_dismount_path,'w')
     614                                        f.close()
     615                                        os.remove(token_dismount_path)
    614616                                else:
    615617                                        if not status['error']:
    616618                                                result=self.mount_drive(profile,mountpoint)
    617                                                 f=open(token_path,'w')
     619                                                f=open(token_mount_path,'w')
    618620                                                f.close()
     621                                                os.remove(token_mount_path)
    619622                                        else:
    620623                                                result['result']=False
     
    649652                directory=[]
    650653               
    651 
    652                 mountpoint=self.profiles_config[profile]["mountpoint"]
     654               
     655                mountpoint=self.profiles_config[profile.decode("utf-8")]["mountpoint"]
     656
    653657                       
    654658               
    655659                try:
    656                         root_folder=self.profiles_config[profile]["root_folder"]
     660                        root_folder=self.profiles_config[profile.decode("utf-8")]["root_folder"]
    657661                except Exception as e:
    658662                        root_folder=False
     
    688692                       
    689693                        tmp_mountpoint=tempfile.mkdtemp('_Gdrive')                                     
    690                         result=self.mount_drive(profile,tmp_mountpoint)
     694                        result=self.mount_drive(profile.decode("utf-8"),tmp_mountpoint)
    691695                               
    692696                        mountpoint=tmp_mountpoint
  • lliurex-gdrive/trunk/WIP_files/lliurexGdriveIndicator

    r6435 r6436  
     1#!/usr/bin/env python
     2
     3import gi
     4gi.require_version('Gtk', '3.0')
     5from gi.repository import Gtk, Pango, GdkPixbuf, Gdk, Gio, GObject, GLib
     6gi.require_version('AppIndicator3', '0.1')
     7from gi.repository import AppIndicator3 as appindicator
     8
     9import os
     10from os import listdir
     11from os.path import isfile, isfile,isdir,join
     12import threading
     13import subprocess
     14import sys
     15import gettext
     16import json
     17import random
     18import notify2
     19import time
     20import datetime
     21import copy
     22
     23
     24import pyinotify
     25from pyinotify import WatchManager, Notifier, ThreadedNotifier, EventsCodes, ProcessEvent
     26
     27import signal
     28signal.signal(signal.SIGINT, signal.SIG_DFL)
     29
     30import lliurex.lliurexgdrive
     31
     32import gettext
     33gettext.textdomain('lliurex-gdrive')
     34_ = gettext.gettext
     35
     36LOCK_INDICATOR="~/.config/lliurex-google-drive-profiles/lgdIndicator.lock"
     37LOCK_GUI="~/.config/lliurex-google-drive-profiles/lgdGUI.lock"
     38RSRC="/usr/share/lliurex-gdrive/"
     39MOUNT_ON_IMAGE=RSRC+"rsrc/mount_on.png"
     40MOUNT_OFF_IMAGE=RSRC+"rsrc/mount_off.png"
     41MOUNT_WARNING_IMAGE=RSRC+"rsrc/mount_warning.png"
     42SP1=RSRC+"rsrc/sp1.png"
     43SP2=RSRC+"rsrc/sp2.png"
     44SP3=RSRC+"rsrc/sp3.png"
     45SP4=RSRC+"rsrc/sp4.png"
     46SP5=RSRC+"rsrc/sp5.png"
     47SP6=RSRC+"rsrc/sp6.png"
     48SP7=RSRC+"rsrc/sp7.png"
     49SP8=RSRC+"rsrc/sp8.png"
     50
     51TIME_CHECK_STATUS=900000
     52
     53class LliurexGdriveIndicator:
     54
     55        WATCH_DIR=os.path.expanduser("~/.config/lliurex-google-drive-profiles/")
     56       
     57        def __init__(self,icon_name):
     58               
     59                self.lock_gui=os.path.expanduser(LOCK_GUI)
     60                self.lock_indicator=os.path.expanduser(LOCK_INDICATOR)         
     61
     62                self.LliurexGoogleDriveManager=lliurex.lliurexgdrive.LliurexGoogleDriveManager()
     63                self.app_indicator=appindicator.Indicator.new("lliurex-gdrive",icon_name,appindicator.IndicatorCategory.APPLICATION_STATUS)
     64                self.app_indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
     65                self.menu = Gtk.Menu()
     66               
     67                self.menu.add_events(Gdk.EventMask.ALL_EVENTS_MASK)
     68                self.app_indicator.set_menu(self.menu)
     69               
     70                self.profiles_info=self.LliurexGoogleDriveManager.profiles_config.copy()
     71                self.current_status={}
     72                self.blacklist=['.Trash','.Trash-1000']
     73                self.init_files=[]
     74                self.update_files=[]
     75                self.local_changes={}
     76
     77                       
     78                self.createLockToken()
     79                self.check_initial_connection()
     80                self.populate_menu()
     81                self.start_inotify()
     82                self.sync_threads={}
     83                self.result_sync_threads={}
     84                self.profile_clicked=[]
     85                self.sp_cont={}
     86                self.sp_img={}
     87                self.checking_status=False
     88               
     89
     90                GLib.timeout_add(TIME_CHECK_STATUS,self.check_status)
     91               
     92        #def __init__
     93
     94        def check_initial_connection(self):
     95               
     96                self.initial_connection=self.LliurexGoogleDriveManager.check_google_connection()
     97                return
     98
     99        #def check_initial_connection   
     100
     101        def generate_sync_threads(self,profile):
     102               
     103                id=int(random.random()*1000)           
     104                t=threading.Thread(target=self.check_sync,args=(id,profile))
     105                t.daemon=True
     106                t.start()
     107                self.sync_threads[id]={}
     108                self.sync_threads[id]["thread"]=t
     109                self.result_sync_threads[id]={}
     110                return id
     111
     112        #def generate_sync_threads     
     113       
     114        def init_connect_thread(self):
     115               
     116                self.check_connect_t=threading.Thread(target=self.check_connect)
     117                self.check_connect_t.daemon=True
     118                self.check_connect_t.start()
     119
     120        #def init_connect_thread       
     121               
     122        def createLockToken(self):
     123
     124                #self.lockpath=os.path(LOCK_INDICATOR)
     125                if not os.path.exists(self.lock_indicator):
     126                        f=open(self.lock_indicator,'w')
     127                        f.close
     128
     129        #def createLockToken
     130                       
     131        def start_inotify(self):
     132
     133                inotify_t=threading.Thread(target=self._inotify)
     134                inotify_t.daemon=True
     135                inotify_t.start()
     136
     137        #def start_inotif
     138
     139
     140        def _inotify(self):
     141               
     142               
     143                wm=WatchManager()
     144                mask= pyinotify.IN_CLOSE_WRITE
     145                     
     146                       
     147                class Process_handler(ProcessEvent):
     148                               
     149                        def __init__(self,main):
     150                               
     151                                self.main=main
     152                       
     153                               
     154                        def process_IN_CLOSE_WRITE(self,event):
     155
     156                                self.main.update_info()
     157                                self.main.initial_connection=True
     158
     159                                if os.path.expanduser(event.pathname)==os.path.join(LliurexGdriveIndicator.WATCH_DIR,"configProfiles"):
     160                                       
     161                                        for profile in self.main.update_profiles:
     162                                                mountpoint_new=self.main.update_profiles[profile]["mountpoint"]
     163                                                gdriveFolder_new=self.main.update_profiles[profile]["gdrive_folder"]
     164                                                if not profile in self.main.profiles_info:
     165                                                        self.main.add_menu_item(profile,mountpoint_new)
     166                                                        wdd=wm.add_watch(mountpoint_new,mask,rec=True)
     167                                                else:
     168                                                        mountpoint_old=self.main.profiles_info[profile]["mountpoint"]
     169                                                        gdriveFolder_old=self.main.profiles_info[profile]["gdrive_folder"]
     170                                                        if (mountpoint_new != mountpoint_old) or (gdriveFolder_new != gdriveFolder_old):
     171                                                                try:
     172                                                                        ide=wm.get_wd(mountpoint_old)
     173                                                                        wdd=wm.rm_watch(ide,rec=True)
     174                                                                except Exception as e:
     175                                                                        print str(e)
     176                                                                        pass   
     177                                                                self.main.remove_folder_info(profile)
     178                                                                self.main.init_folders_info(profile,mountpoint_new)
     179                                                                wdd=wm.add_watch(mountpoint_new,mask,rec=True)
     180
     181                                        profile_rm=""
     182                                        for item in self.main.menu.get_children():
     183                                                if item.profile !="":
     184                                                        if not item.profile in self.main.update_profiles:
     185                                                                self.main.menu.remove(item)
     186                                                                profile_rm=item.profile
     187
     188                                        if profile_rm !="":
     189                                                mountpoint=self.main.profiles_info[profile_rm]["mountpoint"]
     190                                                try:
     191                                                        ide=wm.get_wd(mountpoint)
     192                                                        wdd=wm.rm_watch(ide,rec=True)
     193                                                except Exception as e:
     194                                                        print str(e)
     195                                                        pass
     196
     197                                                self.main.remove_folder_info(profile_rm)                               
     198                                                               
     199
     200                                        self.main.profiles_info=self.main.update_profiles.copy()
     201                                        self.main.menu.show_all()
     202
     203                                else:
     204                                        if 'ountToken' in os.path.basename(event.pathname):
     205                                                        tmp_profile=os.path.basename(event.pathname).split("__")[0]
     206                                                        tmp_profile=tmp_profile.decode("utf-8")
     207                                                        for item in self.main.profiles_info:
     208                                                                if item==tmp_profile:
     209                                                                        tmp_mountpoint=self.main.profiles_info[item]["mountpoint"]
     210                                                                        try:
     211                                                                                ide=wm.get_wd(tmp_mountpoint)
     212                                                                                if id !=None:
     213                                                                                        wdd=wm.rm_watch(ide,rec=True)
     214                                                                        except Exception as e:
     215                                                                                print str(e)
     216                                                                                pass
     217                                                                        self.main.remove_folder_info(item)             
     218                                                                        if 'MountToken' in os.path.basename(event.pathname):
     219                                                                                self.main.init_folders_info(item,tmp_mountpoint)
     220                                                                                wdd=wm.add_watch(tmp_mountpoint,mask,rec=True)
     221                                                                       
     222                                        else:                           
     223                                                time.sleep(2)
     224                                                t=join(event.path,event.name)
     225                                                if isfile(t):
     226                                                       
     227                                                        '''
     228                                                        for item in self.main.profiles_info:
     229                                                                tmp_mount=self.main.profiles_info[item]["mountpoint"]
     230                                                               
     231                                                                if event.path in tmp_mount:
     232                                                                        cmd="google-drive-ocamlfuse -cc -label %s"%item
     233                                                                        os.system(cmd)
     234                                                        '''             
     235                                                                                       
     236                                                        try:
     237                                                               
     238                                                                estado=os.stat(t)
     239                                                               
     240                                                        except Exception as e:
     241                                                                print str(e)
     242                                                                t=t.split('trashinfo')
     243                                                                t=t[0]+'trashinfo'
     244                                                                estado=os.stat(t)
     245                                                               
     246                                                        t=t.decode("utf-8")                     
     247                                                        acceso=datetime.datetime.fromtimestamp(estado.st_mtime)
     248                                                        self.main.local_changes[t]=acceso
     249                                                                               
     250               
     251                notifier=Notifier(wm,Process_handler(self))
     252                wdd=wm.add_watch(LliurexGdriveIndicator.WATCH_DIR,mask,rec=True)
     253               
     254                for profile in self.profiles_info:
     255                        path=os.path.expanduser(self.profiles_info[profile]["mountpoint"])
     256                        wdd=wm.add_watch(path,mask,rec=True)
     257
     258               
     259                while True:
     260                        try:
     261                               
     262                                notifier.process_events()
     263
     264                                if notifier.check_events():
     265                                        notifier.read_events()
     266
     267                        except Exception as e:
     268                                print str(e)
     269                                notifier.stop()
     270               
     271                return False
     272                       
     273       
     274        #def _inotify
     275
     276        def update_info(self):
     277
     278                f=open(self.LliurexGoogleDriveManager.config_file)
     279
     280                try:
     281                        self.update_profiles=json.load(f)
     282                except:
     283                        self.update_profiles={}
     284               
     285                f.close()
     286
     287        #def update_info       
     288       
     289        def add_menu_item(self,profile,mountpoint):
     290
     291                if self.initial_connection:
     292                        status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
     293                        info=self.item_status_info(status_info)
     294                        self.current_status[profile]=status_info["status"]     
     295                else:
     296                        status_info={}
     297                        status_info['status']=None
     298                        status_info['size']=0
     299                        status_info['used']=0
     300                        info=self.item_status_info(status_info)
     301                        self.current_status[profile]=None
     302                               
     303                label_item=profile     
     304                item=Gtk.ImageMenuItem()
     305                item.set_label(label_item)
     306                item.set_image(info["img"])
     307                item.set_tooltip_text(info["tooltip"])
     308                item.profile=profile
     309                item.size=False
     310                item.status=True
     311                item.set_always_show_image(True)
     312                item.connect("activate",self.item_clicked,profile)
     313                self.menu.insert(item,0)
     314
     315               
     316                item=Gtk.MenuItem()
     317                label_item=info["used_size"]
     318                item.set_label(label_item)
     319                item.profile=profile
     320                item.size=True
     321                item.status=False
     322                self.menu.insert(item,1)
     323
     324                item=Gtk.MenuItem()
     325                label_item=_("Open folder")
     326                item.set_label(label_item)
     327                item.connect("activate",self.open_folder,profile)
     328                item.profile=profile
     329                item.size=False
     330                item.status=False
     331                self.menu.insert(item,2)
     332
     333                item=Gtk.MenuItem()
     334                label_item=_("Update cache")
     335                item.set_label(label_item)
     336                item.set_tooltip_text(_("Click if do not see all the files in the Google Drive account"))
     337                item.connect("activate",self.refresh_cache_menu,profile)
     338                item.profile=profile
     339                item.size=False
     340                item.status=False
     341                self.menu.insert(item,3)
     342
     343                item=Gtk.SeparatorMenuItem()
     344                item.profile=profile
     345                item.size=False
     346                item.status=False
     347                self.menu.insert(item,4)
     348                self.init_folders_info(profile,mountpoint)
     349
     350
     351        #def add_menu_item     
     352
     353
     354        def populate_menu(self,empty=True):
     355               
     356               
     357                if empty:
     358                        for c in self.menu.get_children():
     359                                self.menu.remove(c)
     360               
     361               
     362                for profile in self.profiles_info:
     363                        mountpoint=self.profiles_info[profile]["mountpoint"]
     364                        self.add_menu_item(profile,mountpoint)
     365                       
     366                       
     367                item=Gtk.ImageMenuItem()
     368                label_item=_("Open Lliurex GDrive")
     369                item.set_label(label_item)
     370                img=Gtk.Image()
     371                img.set_from_stock(Gtk.STOCK_PREFERENCES,Gtk.IconSize.MENU)
     372                item.set_image(img)
     373                item.set_always_show_image(True)
     374                item.connect("activate",self.open_gui)
     375                item.profile=""
     376                item.size=False
     377                item.status=False
     378                self.menu.append(item)
     379
     380                item=Gtk.ImageMenuItem()
     381                img=Gtk.Image()
     382                img.set_from_stock(Gtk.STOCK_CLOSE,Gtk.IconSize.MENU)
     383                item.set_image(img)
     384                item.set_always_show_image(True)
     385                label_item=_("Close")
     386                item.set_label(label_item)
     387                item.connect("activate",self.quit)
     388                item.profile=""
     389                item.size=False
     390                item.status=False
     391                self.menu.append(item)
     392
     393
     394                self.menu.show_all()
     395               
     396               
     397        #def populate_menu
     398       
     399        def init_folders_info(self,profile,mountpoint):
     400
     401                self.folders_info={}
     402                self.folders_info['profile']=profile
     403                self.files=set()
     404                self.controlDirectory(mountpoint)
     405                self.folders_info['files']=self.files
     406                self.init_files.append(self.folders_info)
     407                       
     408        #def init_folders_info                         
     409
     410
     411        def controlDirectory(self,path):
     412               
     413               
     414                for item in listdir(path):
     415                        if item not in self.blacklist:
     416                               
     417                                t=join(path,item)
     418
     419                                if isfile(t):
     420                                       
     421                                        compartido=False
     422                                        estado=os.stat(t)
     423                                        acceso=datetime.datetime.fromtimestamp(estado.st_mtime)
     424                                        tmp=t+":__"+str(acceso)
     425                                       
     426                                        self.files.add(tmp)
     427                                else:
     428                                        if isdir(t):
     429                                                self.controlDirectory(t)       
     430
     431        #def controlDirectory                                   
     432                                               
     433        def remove_folder_info(self,profile):
     434
     435                i=0
     436                for item in self.init_files:
     437                        if profile ==item["profile"]:
     438                                self.init_files.pop(i)
     439                        i=i+1   
     440
     441        #def remove_folder_info         
     442
     443
     444        def item_clicked(self,widget,profile):
     445       
     446                if profile not in self.profile_clicked:
     447                        self.profile_clicked.append(profile)
     448                        id=self.generate_sync_threads(profile)
     449                        self.sp_cont[id]=0
     450                        self.sp_img[id]=Gtk.Image.new_from_file(SP1)
     451                        GLib.timeout_add(100,self.pulsate_check_sync,id,widget,profile)
     452                       
     453               
     454        #def item_clicked
     455
     456        def spinner_sync(self,id):
     457       
     458                if self.sp_cont[id]>80:
     459                        self.sp_cont[id]=0
     460                       
     461                if self.sp_cont[id]==0:
     462                        img=Gtk.Image.new_from_file(SP1)
     463                        self.sp_img[id]=img
     464                elif self.sp_cont[id]==10:
     465                        img=Gtk.Image.new_from_file(SP2)
     466                        self.sp_img[id]=img                     
     467                elif self.sp_cont[id]==20:
     468                        img=Gtk.Image.new_from_file(SP3)
     469                        self.sp_img[id]=img
     470                elif self.sp_cont[id]==30:
     471                        img=Gtk.Image.new_from_file(SP4)
     472                        self.sp_img[id]=img
     473                elif self.sp_cont[id]==40:
     474                        img=Gtk.Image.new_from_file(SP5)
     475                        self.sp_img[id]=img     
     476                elif self.sp_cont[id]==50:
     477                        img=Gtk.Image.new_from_file(SP6)
     478                        self.sp_img[id]=img     
     479                elif self.sp_cont[id]==60:
     480                        img=Gtk.Image.new_from_file(SP7)
     481                        self.sp_img[id]=img     
     482                elif self.sp_cont[id]==70:
     483                        img=Gtk.Image.new_from_file(SP8)
     484                        self.sp_img[id]=img                             
     485                               
     486        #def spinner_sync       
     487                       
     488        def pulsate_check_sync(self,id,widget,profile):
     489               
     490               
     491                if self.sync_threads[id]["thread"].is_alive():
     492                        self.spinner_sync(id)
     493                        widget.set_image(self.sp_img[id])
     494                        widget.set_tooltip_text(_("Applying changes..."))       
     495                        self.sp_cont[id]=self.sp_cont[id]+1
     496                        return True
     497               
     498                else:
     499                        self.profile_clicked.remove(profile)
     500                        self.current_status[profile]=self.result_sync_threads[id]["status_info"]["status"]     
     501                        if self.result_sync_threads[id]["status_mod"]["result"]==False:
     502                                if self.result_sync_threads[id]["status_mod"]["code"]==8:
     503                                        message=_("Error: Unable to connect with google")       
     504                                else:
     505                                        status=self.current_status[profile]
     506                                        if status:
     507                                                action=_("dismount")
     508                                        else:
     509                                                action=_("mount")       
     510                                        message=_("Error: Unable to ") + action + " "
     511                        else:
     512                                if self.result_sync_threads[id]["status_mod"]["code"]==9:
     513                                        message=_("Status updated. Now you can change it")
     514                                else:
     515                                        message=_("Changes applied successfully")
     516                       
     517                        self.show_message(profile + ": " + message)
     518                       
     519                        info=self.item_status_info(self.result_sync_threads[id]["status_info"])
     520                       
     521                        for item in self.menu.get_children():
     522                                        if item.size:
     523                                                if item.profile==profile:
     524                                                        item.set_label(info["used_size"])
     525                               
     526                        widget.set_tooltip_text(info["tooltip"])
     527                        widget.set_image(info["img"])   
     528                        self.sync_threads.pop(id)
     529                        self.sp_cont.pop(id)
     530                        self.sp_img.pop(id)
     531                        self.result_sync_threads.pop(id)
     532               
     533                return False
     534
     535        #def pulsate_check_sync
     536                       
     537       
     538        def     check_sync(self,id,profile):
     539               
     540                mountpoint=self.profiles_info[profile]["mountpoint"]
     541
     542                current_status=self.current_status[profile]
     543               
     544                self.result_sync_threads[id]["status_mod"],self.result_sync_threads[id]["status_info"]=self.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
     545
     546
     547                #self.result_connect_threads[id]["value"]=self.LliurexGoogleDriveManager.check_google_connection()
     548
     549        #def check_sync
     550       
     551        def open_folder(self,widget,profile):
     552
     553               
     554                mountpoint=self.profiles_info[profile]["mountpoint"]
     555                cmd="caja " + mountpoint.encode("utf-8")
     556
     557                os.system(cmd) 
     558
     559        #def open_folder
     560
     561        def refresh_cache_menu (self,widget,profile):
     562
     563                message=self.refresh_cache_command(profile)
     564               
     565                message=message.decode("UTF-8")
     566
     567                time.sleep(0.5)
     568                self.show_message(profile + ": " + message)     
     569
     570        #def refresh_cache_menu
     571
     572        def refresh_cache_command(self,profile):
     573
     574                profile=profile.encode("utf-8")
     575
     576                try:
     577                        cmd="google-drive-ocamlfuse -cc -label %s"%profile
     578                        os.system(cmd)
     579                        message=_("Cache updated successfully")
     580                               
     581                except Exception as e:
     582                        message=_("An error occurred updating the cache. Try again")
     583
     584                return message 
     585
     586        #def refresh_cache_command     
     587
     588        def open_gui(self,widget):
     589               
     590                if not os.path.exists(self.lock_gui):
     591                        cmd='/usr/bin/lliurex-gdrive' +"&"
     592                        os.system(cmd)
     593
     594        #def open_gui
     595               
     596        def item_status_info(self,status_info):
     597       
     598                size=status_info["size"]
     599                used=status_info["used"]
     600
     601                if status_info['status']==None:
     602                        img=Gtk.Image.new_from_file(MOUNT_WARNING_IMAGE)
     603                        tooltip=_("Without connection. Clicked to update")
     604                        used_size=_("Used: not available")
     605               
     606                elif    status_info["status"]:
     607                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
     608                        tooltip=_("Mounted. Clicked to dismount now")
     609                        used_size=_("Used: %s of %s")%(used,size)
     610               
     611                else:
     612                        img=Gtk.Image.new_from_file(MOUNT_OFF_IMAGE)
     613                        tooltip=_("Dismounted. Clicked to mount now")
     614                        used_size=_("Used: not available")     
     615
     616                return {"img":img ,"tooltip":tooltip, "used_size":used_size}   
     617
     618        #def item_status_info                   
     619
     620        def check_status(self):
     621               
     622                if not self.checking_status:
     623                        self.checking_status=True
     624                        self.init_connect_thread()
     625                        GLib.timeout_add(100,self.get_status_info,id)
     626
     627                return True
     628               
     629               
     630        #def check_status
     631       
     632        def get_status_info(self,id):
     633               
     634                if self.check_connect_t.is_alive():
     635                        return True
     636               
     637                else:   
     638                        self.update_files=[]
     639                        self.checking_status=False
     640                        #self.connect_threads.pop(id)
     641                        for profile in self.profiles_info:
     642                                if self.connection:
     643                                        self.refresh_cache_command(profile)
     644                                        mountpoint=self.profiles_info[profile]["mountpoint"]
     645                                        status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
     646                                        self.update_folders_info(profile,mountpoint)
     647
     648                                else:
     649                                        status_info={}
     650                                        status_info['status']=None
     651                                        status_info['size']=0
     652                                        status_info['used']=0
     653                                       
     654                                info=self.item_status_info(status_info)
     655                                self.current_status[profile]=status_info["status"]
     656                                                               
     657                                for item in self.menu.get_children():
     658                                        if item.profile==profile:
     659                                                if item.size:
     660                                                        item.set_label(info["used_size"])
     661                                                if item.status:
     662                                                        item.set_tooltip_text(info["tooltip"])
     663                                                        item.set_image(info["img"])
     664               
     665                #self.result_connect_threads.pop(id)           
     666                self.notify_changes()
     667                return False   
     668
     669        #def get_status_info   
     670                                       
     671        def check_connect(self):
     672               
     673                self.connection=self.LliurexGoogleDriveManager.check_google_connection()
     674
     675        #def check_connect     
     676
     677        def update_folders_info(self,profile,mountpoint):
     678
     679                self.folders_info={}
     680                self.folders_info['profile']=profile
     681                self.files=set()
     682               
     683                self.controlDirectory(mountpoint)
     684                self.folders_info['files']=self.files
     685                self.update_files.append(self.folders_info)     
     686
     687        #def update_folders_info       
     688                               
     689
     690        def notify_changes(self):
     691
     692
     693                if self.init_files!=self.update_files:
     694                        toInfo=self.remove_local_changes()
     695
     696                        for item in toInfo:
     697                                numFiles_up=0
     698                                numFiles_rm=0
     699                                numFiles_add=0
     700                                p=item['profile']
     701                                if 'files_changes' in item:
     702                                        numFiles_up=len(item['files_changes'])
     703                               
     704                                if 'files_delete' in item:     
     705                                        numFiles_rm=len(item['files_delete'])
     706                               
     707                                if 'files_add' in item:
     708                                        numFiles_add=len(item['files_add'])
     709                               
     710                                if numFiles_up>0 or numFiles_rm>0 or numFiles_add>0:
     711                                        message1=_('Changes in last 15 minutes in ')+p+':\n'
     712                                        message_up=""
     713                                        message_rm=""
     714                                        message_add=""         
     715                                        if numFiles_up>0:
     716                                                message_up=_("-Files updated: ")
     717                                                if numFiles_up==1:
     718                                                        for element in item['files_changes']:
     719                                                                file=os.path.basename(element.split(":__")[0])
     720                                                                file_split=os.path.splitext(file)
     721                                                                if file_split[1]==".desktop":
     722                                                                        file=file_split[0]
     723                                                                message_up=message_up + file +'\n'
     724                                                                       
     725                                                else:   
     726                                                        message_up= message_up + str(numFiles_up) + '\n'
     727
     728                                        if numFiles_add>0:
     729                                                message_add=_("-Files added: ")
     730                                                if numFiles_add==1:
     731                                                        for element in item['files_add']:
     732                                                                file=os.path.basename(element.split(":__")[0])
     733                                                                file_split=os.path.splitext(file)
     734                                                                if file_split[1]==".desktop":
     735                                                                        file=file_split[0]
     736                                                                message_add=message_add +file +'\n'
     737                                                else:
     738                                                               
     739                                                        message_add=message_add + str(numFiles_add) + '\n'
     740
     741                                        if numFiles_rm>0:
     742                                                message_rm=_("-Files deleted: ")       
     743                                                if numFiles_rm==1:
     744                                                        for element in item['files_delete']:
     745                                                                file=os.path.basename(element.split(":__")[0]) 
     746                                                                file_split=os.path.splitext(file)
     747                                                                if file_split[1]==".desktop":
     748                                                                        file=file_split[0]
     749                                                                message_rm=message_rm + file +'\n'
     750                                                else:           
     751                                                        message_rm=message_rm +str(numFiles_rm)
     752
     753                                        self.show_message(message1 + message_add + message_up + message_rm)
     754
     755                self.init_files=copy.copy(self.update_files)
     756                self.local_changes={}
     757
     758        #def notify_changes
     759       
     760        def remove_local_changes(self):
     761
     762                changes=self.detect_folder_changes()
     763
     764                changes_toNotify=[]
     765               
     766                if len(changes)>0:
     767
     768                        for item in changes:
     769                                tmp_changes=[]
     770                                tmp_deletes=[]
     771                                tmp_add=[]
     772                                to_info={}
     773                                to_info['profile']=item['profile']
     774
     775                                if 'files_changes' in item:
     776                                        tmp_changes=item['files_changes']
     777                                        toInfo_up=tmp_changes.copy()
     778                                if 'files_deletes' in item:
     779                                        tmp_deletes=item['files_deletes']       
     780                                        toInfo_rm=tmp_deletes.copy()
     781
     782                                if 'files_add' in item:
     783                                        tmp_add=item['files_add']       
     784                                        toInfo_add=tmp_add.copy()
     785
     786
     787                                if len(self.local_changes)>0:
     788                                        if len(tmp_changes)>0:
     789                                                for item in tmp_changes:
     790                                                        #file=item.keys()[0]
     791                                                        file=item.split(":__")[0]
     792                                                        data=item.split(":__")[1]
     793                                                        for i in self.local_changes:
     794                                                                if file==i:
     795                                                                        data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
     796                                                                        if data<=self.local_changes[i]:
     797                                                                                toInfo_up.remove(item)
     798                                                to_info['files_changes']=toInfo_up                             
     799                                        if len(tmp_deletes)>0:
     800                                                for item in tmp_deletes:
     801                                                        file=os.path.basename(item.split(":__")[0])
     802                                                        file=os.path.splitext(file)[0]
     803                                                        data=item.split(":__")[1]
     804                                                        for i in self.local_changes:
     805                                                                if file in i:
     806                                                                        data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
     807                                                                        if data<=self.local_changes[i]:
     808                                                                                toInfo_rm.remove(item)
     809                                                to_info['files_delete']=toInfo_rm                                       
     810
     811                                        if len(tmp_add)>0:
     812                                                for item in tmp_add:
     813                                                        file=item.split(":__")[0]
     814                                                        data=item.split(":__")[1]
     815                                                        for i in self.local_changes:
     816                                                                if file==i:
     817                                                                        data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
     818                                                                        if data<=self.local_changes[i]:
     819                                                                                toInfo_add.remove(item)
     820                                                to_info['files_add']=toInfo_add
     821                                else:
     822                                        to_info['files_changes']=tmp_changes
     823                                        to_info['files_delete']=tmp_deletes
     824                                        to_info['files_add']=tmp_add           
     825
     826                                changes_toNotify.append(to_info)
     827
     828                return changes_toNotify
     829
     830        #def remove_local_changes
     831
     832
     833        def detect_folder_changes(self):
     834
     835                changes=[]
     836                               
     837               
     838                for item in self.update_files:
     839                        info_changes={}
     840                        info_changes['profile']=item['profile']
     841                        final_files=item['files']
     842
     843                        for item in self.init_files:
     844                                profile_init=item['profile']
     845                                original_files=item['files']
     846                                if len(original_files)>0:
     847                                        if len(final_files)>0:
     848                                                if info_changes['profile']==profile_init:
     849                                                        diff_changes=final_files.difference(original_files)
     850                                                        diff_deletes=original_files.difference(final_files)
     851                                                       
     852                                                        if len(diff_changes)>0:
     853                                                                changes.append(info_changes)
     854
     855                                                                if len(diff_deletes)>0:
     856                                                                                tmp_del=diff_deletes.copy()
     857                                                                                tmp_add=diff_changes.copy()
     858                                                                                for item in diff_deletes:
     859                                                                                        file_d=item.split(":__")[0]
     860                                                                                        for element in diff_changes:
     861                                                                                                file_c=element.split(":__")[0]
     862                                                                                                if file_d == file_c:
     863                                                                                                        tmp_del.remove(item)
     864                                                                                                        tmp_add.remove(element)
     865
     866                                                                                if len(tmp_del)>0:
     867                                                                                        info_changes['files_deletes']=tmp_del
     868
     869                                                                                if len(tmp_add)>0:
     870                                                                                        info_changes['files_add']=tmp_add
     871                                                                                        tmp_up=diff_changes.difference(tmp_add)
     872                                                                                        info_changes['files_changes']=tmp_up
     873                                                                                else:
     874                                                                                        info_changes['files_changes']=diff_changes     
     875                                                                                               
     876                                                                else:
     877                                                                        info_changes['files_add']=diff_changes                 
     878                                                        else:
     879                                                                if len(original_files)>len(final_files) and len(diff_deletes)>0:
     880                                                                        info_changes['files_deletes']=diff_deletes
     881                                                                        changes.append(info_changes)
     882                               
     883                                                       
     884                return changes 
     885
     886        #def detect_folder_changes                                                                     
     887       
     888
     889        def show_message(self,message):
     890                notify2.init("test")
     891                n=notify2.Notification("Lliurex-GDrive",message,"gdrive")
     892                n.show()
     893                return
     894
     895        #def show_message       
     896                               
     897       
     898        def cleanIndicatorLock(self):
     899
     900                if os.path.exists(self.lock_indicator):
     901                        os.remove(self.lock_indicator)
     902
     903        #def cleanIndicatorLock                 
     904       
     905        def quit(self,widget):
     906
     907                self.cleanIndicatorLock()
     908                Gtk.main_quit()
     909
     910        #def quit       
     911
     912       
     913#class LliurexGdriveIndicator
     914
     915if __name__=="__main__":
     916       
     917        lliurexgdrive=LliurexGdriveIndicator("gdrive")
     918        GObject.threads_init()
     919        Gtk.main()
     920       
Note: See TracChangeset for help on using the changeset viewer.