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

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

Fix encode

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