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

Last change on this file since 5803 was 5803, checked in by jrpelegrina, 2 years ago

Checkedblank in mountpoint

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