source: lliurex-gdrive/trunk/fuentes/python-lliurex-gdrive/lliurex/lliurexgdrive/__init__.py @ 5661

Last change on this file since 5661 was 5661, checked in by jrpelegrina, 3 years ago

Wip in check empty folder when profile is created or updated

  • Property svn:executable set to *
File size: 11.9 KB
Line 
1#!/usr/bin/env python
2import glob
3import ConfigParser
4import os
5import json
6import subprocess
7import shutil
8import urllib2
9import datetime
10
11
12DEBUG=False
13GDRIVE_CONFIG_DIR=os.path.expanduser("~/.gdfuse/")
14LLIUREX_CONFIG_FILE='/usr/share/lliurex-gdrive/llx-data/config'
15
16
17class LliurexGoogleDriveManager(object):
18
19        def __init__(self):
20
21                super(LliurexGoogleDriveManager, self).__init__()
22
23                self.config_dir=os.path.expanduser("~/.config/lliurex-google-drive-profiles/")
24                self.config_file=self.config_dir+"configProfiles"
25               
26                self.mount_cmd="google-drive-ocamlfuse -label %s %s"
27                self.clean_cache="google-drive-ocamlfuse -cc -label %s"
28
29                self.read_conf()
30               
31
32        #def init
33
34        def create_conf(self):
35
36                if not os.path.exists(self.config_dir):
37                        os.makedirs(self.config_dir)
38
39                var={}
40                # var["default"]={}
41                # var["default"]["email"]=""
42                # var["default"]["mountpoint"]=""
43                # var["default"]["automount"]=""
44
45                f=open(self.config_file,"w")
46                data=unicode(json.dumps(var,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
47
48                f.write(data)
49                f.close()
50
51                msg_log="Creating conf..."
52                self.dprint(msg_log)
53               
54
55        #def create_conf
56       
57        def read_conf(self):
58               
59                if not os.path.exists(self.config_file):
60                        self.create_conf()
61               
62                log_msg="------------------------------------------\n"+"LLIUREX-GDRIVE STARTING AT: " + datetime.datetime.today().strftime("%d/%m/%y %H:%M:%S") +"\n------------------------------------------"
63                self.log(log_msg)
64                msg_log="Init: Reading conf..."
65                self.dprint(msg_log)
66                self.log(msg_log)
67                       
68                f=open(self.config_file)
69                try:
70                        self.profiles_config=json.load(f)
71                except:
72                        self.profiles_config={}
73                f.close()
74               
75        #def read_conf
76       
77        def check_config(self,profile):
78               
79                path=GDRIVE_CONFIG_DIR+profile+"/state"
80                profile=profile.encode("utf-8")
81
82                if os.path.exists(path):
83                        f=open(path)
84                        line=f.readline()
85                        f.close()
86               
87                        if "1970-" in line:
88                                msg_log="Check config: '%s' not configured"%profile
89                                self.dprint(msg_log)
90                                self.log(msg_log)
91                                return False
92                       
93                        msg_log="Check config: '%s' yet configured"%profile
94                        self.dprint(msg_log)
95                        self.log(msg_log)
96                        return True
97
98                else:
99                        msg_log="Check config: '%s' not yet create"%profile
100                        self.dprint(msg_log)
101                        self.log(msg_log)
102                        return False
103
104               
105        #def check_config
106
107        def check_google_connection(self):
108
109                try:
110                        req=urllib2.Request("http://google.com")
111                        res=urllib2.urlopen(req)
112                        return True
113                except:
114                        msg_log="Check connection: Cannot connect to google.com"
115                        self.dprint(msg_log)
116                        self.log(msg_log)
117                        return False
118
119        #def check_google_connection           
120       
121        def mount_drive(self,profile,mountpoint):
122               
123                #profile=profile.encode("utf-8")
124                #mountpoint=mountpoint.encode("utf-8")
125                               
126                try:
127                       
128                        if os.path.exists(GDRIVE_CONFIG_DIR+profile):
129                                check= self.check_config(profile)
130                                if check:
131                                        #if profile in self.profiles_config:
132                                                #mount_point=os.path.expanduser(self.profiles_config[profile]["mountpoint"])
133                                                #if type(mount_point)==type(u""):
134                                                if mountpoint!="":
135                                                        self.dprint("Mounting '%s'..."%profile)
136                                                        if not os.path.exists(mountpoint):
137                                                                try:
138                                                                        os.makedirs(mountpoint)
139                                                                except:
140                                                                        msg_log="Mount drive: Unable to create '%s' mount destination"%mountpoint.encode("utf-8")
141                                                                        self.dprint(msg_log)
142                                                                        self.log(msg_log)
143                                                                        return {"result":False,"code":1}
144                                                               
145
146                                                        if os.access(mountpoint,os.W_OK):
147                                                                #os.system(self.mount_cmd%(profile,mountpoint))
148                                                                cmd=self.mount_cmd%(profile,mountpoint)
149                                                                p=subprocess.Popen(cmd,shell=True, stdout=subprocess.PIPE,stderr=subprocess.PIPE)
150                                                                poutput,perror=p.communicate()
151                                                                if len(perror)==0:
152                                                                        msg_log="Mount drive: drive '%s' mounted sucessfully:"%mountpoint.encode("utf-8")
153                                                                        self.dprint(msg_log)
154                                                                        self.log(msg_log)
155                                                                        return {"result":True,"code":0}
156
157                                                                else:
158                                                                        msg_log="Mount drive: Error mount '%s': %s"%(mountpoint.encode("utf-8"),str(perror))
159                                                                        self.code=2
160                                                                        self.dprint(msg_log)
161                                                                        self.log(msg_log)
162                                                                                                                                       
163                                                        else:
164                                                                msg_log="Mount drive: Mount drive: '%s' mount destination is not owned by user"%mountpoint.encode("utf-8")
165                                                                self.code=3
166                                                                self.dprint(msg_log)
167                                                                self.log(msg_log)
168                                                               
169                                                else:
170                                                        msg_log="Mount drive: No mount point indicated"
171                                                        self.code=4
172                                                        self.dprint(msg_log)
173                                                        self.log(msg_log)
174                                else:
175                                        msg_log="Mount drive: '%s' mount point not configured"%profile.encode("utf-8")
176                                        self.code=5
177                                        self.dprint(msg_log)
178                                        self.log(msg_log)
179                        else:
180                                msg_log="Mount drive: '%s' GDrive profile path does not exist"%profile.encode("utf-8")
181                                self.code=6
182                                self.dprint(msg_log)
183                                self.log(msg_log)
184                               
185                except Exception as e:
186
187                        raise e
188                       
189                       
190                return {"result":False,"code":self.code} 
191
192        #def mount_drive
193       
194        def mount_drives(self):
195               
196                if self.check_google_connection():
197                        for profile in self.profiles_config:
198                                automount=self.profiles_config[profile]["automount"]
199                                if automount:
200                                        mountpoint=self.profiles_config[profile]["mountpoint"]
201                                        #profile=profile.encode("utf-8")
202                                        #mountpoint=mountpoint.encode("utf-8")
203                                        self.mount_drive(profile,mountpoint)
204                                               
205               
206        #def mount_drives
207
208        def dprint(self,msg):
209               
210                if DEBUG:
211                        print("[LGDM] %s"%msg)
212                       
213        #def dprint
214       
215       
216        def save_profiles(self,info):
217               
218                self.profiles_config=info
219               
220                f=open(self.config_file,"w")
221                #data=json.dumps(info,indent=4,encoding="utf-8",ensure_ascii=False)
222                data=unicode(json.dumps(info,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
223                f.write(data)
224                f.close()
225
226        #def save_profiles     
227
228        def check_mountpoint_status(self,mountpoint,arg=None):
229
230                mountpoint_size=""
231                mountpoint_used=""
232                mountpoint_available=""
233                mountpoint_per=""
234                tmp=[]
235                connect=True
236               
237                if arg!=None:
238                        connect=self.check_google_connection()
239               
240                if connect:
241                        command='df -h | grep "google-drive-ocamlfuse" | grep ' +mountpoint+'$' 
242                               
243                        p=subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
244                        poutput,perror=p.communicate()
245
246                        if len(poutput)>0:
247                                status=True
248
249                                for item in poutput.split(" "):
250                                        if len(item)>1:
251                                                tmp.append(item)
252
253                                mountpoint_size=tmp[1]
254                                mountpoint_used=tmp[2]
255                                mountpoint_available=tmp[3]
256                                mountpoint_per=tmp[4]
257
258                        else:
259                                status=False
260                else:
261                        status=None
262                                       
263                return {"status":status,"size":mountpoint_size,"used":mountpoint_used,"available":mountpoint_available,"used%":mountpoint_per}         
264               
265        #def check_mountpoint_status   
266               
267        def check_profile_info(self,profile,mountpoint,edition):
268       
269                '''
270                        code=0: Form OK
271                        code=1: Profile empty
272                        code=2: Profile with blanck spaces
273                        code=3: Profile duplicate
274                        code=4: Mountpoint duplicate
275                        code=5: Mountpoint not empty
276                        code=6: Mountpoint not owned by user
277
278                '''     
279                #profile=profile.decode("utf-8")
280                if not edition:
281
282                       
283                        # type(unicode) ==> encode("utf-8")
284                        # type(str) ==> decode("utf-8")
285                       
286
287                        if profile=="":
288                                return {"result":False,"code":1}
289
290                        if ' ' in profile:
291                                return {"result":False,"code":2}
292       
293                        else:
294                                for item in self.profiles_config:
295                                        if profile==item:
296                                                return {"result":False,"code":3}
297
298                for item in self.profiles_config:
299                        if profile!=item:
300
301                                if not os.access(mountpoint,os.W_OK):
302                                        return {"result":False,"code":6}
303
304                                if os.listdir(mountpoint):
305                                        return {"result":False,"code":5}       
306
307                                if mountpoint==self.profiles_config[item]["mountpoint"]:
308                                        return {"result":False,"code":4}
309                       
310
311                return {"result":True,"code":0}                                                         
312       
313        #def check_profile_info
314
315        def create_profile(self,profile):
316
317                #profile=unicode(profile).encode("utf-8")
318                path=GDRIVE_CONFIG_DIR+profile+"/config"
319
320                if not self.check_config(profile):
321                        os.system("google-drive-ocamlfuse -label %s"%unicode(profile).encode("utf-8"))
322                        msg_log=("'%s' profile has been create")%profile.encode("utf-8")
323                        self.log(msg_log)
324                        self.dprint(msg_log)
325
326                        if os.path.exists(GDRIVE_CONFIG_DIR+profile):
327                                shutil.copy(LLIUREX_CONFIG_FILE,path )
328               
329                return True
330                               
331                       
332        #def create_profile
333
334        def create_mountpoint(self,info,profile):
335
336                mountpoint=info[profile]["mountpoint"]
337
338                result=self.mount_drive(profile,mountpoint)
339               
340                if result["result"]:
341                        self.save_profiles(info)
342                else:
343                        if profile !="":
344                                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
345                                        shutil.rmtree(os.path.join(GDRIVE_CONFIG_DIR+profile))
346                                        self.dprint("'%s' profile has been delete"%profile)
347                       
348                return result
349
350        #def create_mountpoint 
351
352        def dismount_mountpoint(self,profile,mountpoint):
353
354                cmd='fusermount -u -z ' + mountpoint + ";"+self.clean_cache%profile
355                p=subprocess.Popen(cmd, shell=True,stdout=subprocess.PIPE, stderr=subprocess.PIPE)
356                poutput,perror=p.communicate()
357
358                mountpoint=mountpoint.encode("utf-8")
359                if len(perror)>0:
360                        print perror
361                        msg_log="Dismount mountpoint: Error dismounted '%s': '%s'"%(mountpoint,str(perror))
362                        self.dprint(msg_log)
363                        self.log(msg_log)
364                        result=False
365                        code=7
366                else:
367                        msg_log="Dismount mountpoint:'%s' mountpoint has been dismounted"%mountpoint
368                        self.dprint(msg_log)
369                        self.log(msg_log)
370                        result=True
371                        code=0                                 
372
373                return {"result":result,"code":code}
374
375        #def dismount_mountpoint       
376
377        def delete_profile(self,info,profile):
378
379                result={}
380                dismount={}
381                dismount["result"]=True
382                dismount["code"]=0
383
384                connect=self.check_google_connection()
385                #profile=str(profile)
386                #if connect:
387                mountpoint=self.profiles_config[profile]["mountpoint"]
388                       
389                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
390                        is_mountpoint_mounted=self.check_mountpoint_status(mountpoint,True)
391
392                        if is_mountpoint_mounted["status"]==None:
393                                print "SIN RED"
394                                result['result']=False
395                                result['code']=8
396                        else:
397                                if is_mountpoint_mounted["status"]:     
398                                        dismount=self.dismount_mountpoint(profile,mountpoint)
399
400                                if dismount["result"]:
401                                        if profile!="":
402                                                shutil.rmtree(os.path.join(GDRIVE_CONFIG_DIR+profile))
403                                                msg_log="Delete profile: '%s' profile has been delete"%profile.encode("utf-8")
404                                                self.log(msg_log)
405                                                self.dprint(msg_log)
406                                        self.save_profiles(info)
407                               
408                                return dismount
409                               
410
411                else:
412                        self.save_profiles(info)
413                        msg_log="Delete profile: '%s' GDrive profile path does not exist"%profile.encode("utf-8")
414                        self.log(msg_log)
415                        self.dprint(msg_log)
416                        result['result']=True
417                        result['code']=0
418               
419                return result
420               
421               
422       
423        # delete_profile       
424
425       
426        def edit_profile(self,info,profile):
427
428                result={}
429                result["result"]=True
430                result["code"]=0
431
432                old_mountpoint=self.profiles_config[profile]["mountpoint"]
433                old_automount=self.profiles_config[profile]["automount"]
434                new_mountpoint=info[profile]["mountpoint"]
435                new_automount=info[profile]["automount"]
436
437                if old_mountpoint!=new_mountpoint:
438                        status=self.check_mountpoint_status(old_mountpoint)
439                       
440                        if status["status"]:
441                                result=self.dismount_mountpoint(profile,old_mountpoint)
442                               
443                                if result["result"]:
444                                        result=self.mount_drive(profile,new_mountpoint)
445                               
446
447                if result["result"]:
448                        self.save_profiles(info)
449                        msg_log="Edit profile: '%s' profile has been edited"%profile.encode("utf-8")
450                        self.log(msg_log)
451                        self.dprint(msg_log)
452
453               
454                return {"result":result["result"],"code":result["code"]}               
455
456        #def edit_profile                       
457
458        def sync_profile(self,profile,mountpoint,current_status):
459               
460                result={}
461                status=self.check_mountpoint_status(mountpoint,True)
462                print status
463       
464                if status["status"]==None:
465                        result['result']=False
466                        result['code']=8
467                       
468                else:
469                        if current_status!=None and status['status']==current_status:
470                                if status['status']:
471                                        result=self.dismount_mountpoint(profile,mountpoint)
472                                else:
473                                        result=self.mount_drive(profile,mountpoint)
474                       
475                        else:
476                                result['result']=True
477                                result['code']=9
478                               
479                        status=self.check_mountpoint_status(mountpoint) 
480               
481                print result
482                return result,status           
483                #result["result"]:result["result"]
484                #result["code"]:result["code"]
485                #return {"result":result["result"],"code":result["code"]}       
486
487        #def_sync_profile       
488
489        def log(self,msg):
490               
491                log_file=self.config_dir+"lliurex-gdrive.log"
492
493                f=open(log_file,"a+")
494                f.write(msg + '\n')
495                f.close()       
496
497        #def log                 
498
499if __name__=="__main__":
500
501        llxgd=LliurexGoogleDriveManager()
502        llxgd.mount_drives()
503       
504       
505       
506        #llxgd.save_profiles(llxgd.var)
507       
508
509
510
511
512
513
514
515
516
Note: See TracBrowser for help on using the repository browser.