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

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

Add dessktop file and fix some files

  • Property svn:executable set to *
File size: 9.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=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                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
123                        check= self.check_config(profile)
124                        if check:
125                                #if profile in self.profiles_config:
126                                        #mount_point=os.path.expanduser(self.profiles_config[profile]["mountpoint"])
127                                        #if type(mount_point)==type(u""):
128                                        if mountpoint!="":
129                                                self.dprint("Mounting '%s'..."%profile)
130                                                if not os.path.exists(mountpoint):
131                                                        try:
132                                                                os.makedirs(mountpoint)
133                                                        except:
134                                                                msg_log="Mount drive: Unable to create '%s' mount destination"%mountpoint
135                                                                self.dprint(msg_log)
136                                                                self.log(msg_log)
137                                                                return False
138                                                       
139
140                                                if os.access(mountpoint,os.W_OK):
141                                                        #os.system(self.mount_cmd%(profile,mountpoint))
142                                                        cmd=self.mount_cmd%(profile,mountpoint)
143                                                        p=subprocess.Popen(cmd,shell=True, stdout=subprocess.PIPE,stderr=subprocess.PIPE)
144                                                        poutput,perror=p.communicate()
145                                                        if len(perror)==0:
146                                                                msg_log="Mount drive: drive '%s' mounted sucessfully:"%(mountpoint.encode("utf-8"))
147                                                                self.dprint(msg_log)
148                                                                self.log(msg_log)
149                                                                return True
150
151                                                        else:
152                                                                msg_log="Mount drive: Error mount '%s': %s"%(mountpoint.encode("utf-8"),str(perror))
153                                                                self.dprint(msg_log)
154                                                                self.log(msg_log)
155                                                                                                                               
156                                                else:
157                                                        msg_log="Mount drive: Mount drive: '%s' mount destination is not owned by user"%mountpoint
158                                                        self.dprint(msg_log)
159                                                        self.log(msg_log)
160                                                       
161                                        else:
162                                                msg_log="Mount drive: '%s' mountpoint not configured"%profile
163                                                self.dprint(msg_log)
164                                                self.log(msg_log)
165                        else:
166                                msg_log="Mount drive: '%s' profile unknown"%profile
167                                self.dprint(msg_log)
168                                self.log(msg_log)
169                else:
170                        msg_log="Mount drive: '%s' GDrive profile path does not exist"%profile.encode("utf-8")
171                        self.dprint(msg_log)
172                        self.log(msg_log)
173                       
174                       
175                return False 
176
177        #def mount_drive
178       
179        def mount_drives(self):
180               
181                for profile in self.profiles_config:
182                        automount=self.profiles_config[profile]["automount"]
183                        if automount:
184                                mountpoint=self.profiles_config[profile]["mountpoint"]
185                                self.mount_drive(profile,mountpoint)
186                                               
187               
188        #def mount_drives
189
190        def dprint(self,msg):
191               
192                if DEBUG:
193                        print("[LGDM] %s"%msg)
194                       
195        #def dprint
196       
197       
198        def save_profiles(self,info):
199               
200                self.profiles_config=info
201               
202                f=open(self.config_file,"w")
203                #data=json.dumps(info,indent=4,encoding="utf-8",ensure_ascii=False)
204                data=unicode(json.dumps(info,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
205                f.write(data)
206                f.close()
207
208        #def save_profiles     
209
210        def check_mountpoint_status(self,mountpoint):
211
212                mountpoint_size=""
213                mountpoint_used=""
214                mountpoint_available=""
215                mountpoint_per=""
216
217               
218                command='df -h | grep "google-drive-ocamlfuse" | grep ' +mountpoint
219               
220                p=subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
221                poutput,perror=p.communicate()
222
223                if len(poutput)>0:
224                        status=True
225                        mountpoint_size=poutput.split(" ")[4]
226                        mountpoint_used=poutput.split(" ")[8]
227                        mountpoint_available=poutput.split(" ")[11]
228                        mountpoint_per=poutput.split(" ")[14]
229
230                else:
231                        status=False
232
233                return {"status":status,"size":mountpoint_size,"used":mountpoint_used,"available":mountpoint_available,"used%":mountpoint_per}         
234               
235        #def check_mountpoint_status   
236               
237        def check_profile_info(self,profile,mountpoint,edition):
238       
239                '''
240                        code=0: Form OK
241                        code=1: Profile empty
242                        code=2: Profile duplicate
243                        code=3: Mountpoint duplicate
244
245                '''     
246                #profile=profile.decode("utf-8")
247                if not edition:
248
249                       
250                        # type(unicode) ==> encode("utf-8")
251                        # type(str) ==> decode("utf-8")
252                       
253
254                        if profile=="":
255                                return {"result":False,"code":1}
256                        else:
257                                for item in self.profiles_config:
258                                        if profile==item:
259                                                return {"result":False,"code":2}
260
261                for item in self.profiles_config:
262                        if profile!=item:
263                                if mountpoint==self.profiles_config[item]["mountpoint"]:
264                                        return {"result":False,"code":3}
265
266                return {"result":True,"code":0}                                                         
267       
268        #def check_profile_info
269
270        def create_profile(self,profile):
271
272                print profile,type(profile)
273
274                profile=unicode(profile).encode("utf-8")
275                path=GDRIVE_CONFIG_DIR+profile+"/config"
276
277                if not self.check_config(profile):
278                        os.system("google-drive-ocamlfuse -label %s"%profile)
279                        msg_log=("'%s' profile has been create")%profile
280                        self.log(msg_log)
281                        self.dprint(msg_log)
282
283                        if os.path.exists(GDRIVE_CONFIG_DIR+profile):
284                                shutil.copy(LLIUREX_CONFIG_FILE,path )
285               
286                return True
287                               
288                       
289        #def create_profile
290
291        def create_mountpoint(self,info,profile):
292
293                mountpoint=info[profile]["mountpoint"]
294
295                result=self.mount_drive(profile,mountpoint)
296               
297                if result:
298                        self.save_profiles(info)
299                else:
300                        if profile !="":
301                                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
302                                        shutil.rmtree(os.path.join(GDRIVE_CONFIG_DIR+profile))
303                                        self.dprint("'%s' profile has been delete"%profile)
304                       
305                return result
306
307        #def create_mountpoint 
308
309        def dismount_mountpoint(self,mountpoint):
310
311                cmd='fusermount -u ' + mountpoint
312                p=subprocess.Popen(cmd, shell=True,stdout=subprocess.PIPE, stderr=subprocess.PIPE)
313                poutput,perror=p.communicate()
314
315                if len(perror)>0:
316                        msg_log="Dismount mountpoint: Error dismounted '%s': '%s'"%(mountpoint,str(perror))
317                        self.log(msg_log)
318                        self.dprint(msg_log)
319                        result=False
320                else:
321                        msg_log=("Dismount mountpoint:'%s' mountpoint has been dismounted"%mountpoint)
322                        self.log(msg_log)
323                        self.dprint(msg_log)
324                        result=True                                     
325
326                return result
327
328        #def dismount_mountpoint       
329
330        def delete_profile(self,info,profile):
331
332                result=True
333                dismount=True
334
335                #profile=str(profile)
336                mountpoint=self.profiles_config[profile]["mountpoint"]
337                print mountpoint
338
339
340                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
341                        is_mountpoint_mounted=self.check_mountpoint_status(mountpoint)
342
343                        if is_mountpoint_mounted["status"]:
344                                dismount=self.dismount_mountpoint(mountpoint)
345
346                        if dismount:
347                                if profile!="":
348                                        shutil.rmtree(os.path.join(GDRIVE_CONFIG_DIR+profile))
349                                        msg_log=("Delete profile: '%s' profile has been delete"%profile)
350                                        self.log(msg_log)
351                                        self.dprint(msg_log)
352                                self.save_profiles(info)
353                                return dismount                 
354
355                else:
356                        self.save_profiles(info)
357                        msg_log="Delete profile: '%s' GDrive profile path does not exist"%profile
358                        self.log(msg_log)
359                        self.dprint(msg_log)
360                       
361                        return True
362               
363       
364        # delete_profile       
365
366       
367        def edit_profile(self,info,profile):
368
369                result=True
370                old_mountpoint=self.profiles_config[profile]["mountpoint"]
371                old_automount=self.profiles_config[profile]["automount"]
372                new_mountpoint=info[profile]["mountpoint"]
373                new_automount=info[profile]["automount"]
374
375                print old_mountpoint
376                print new_mountpoint
377
378                if old_mountpoint!=new_mountpoint:
379                        status=self.check_mountpoint_status(old_mountpoint)
380
381                        if status["status"]:
382                                dismount=self.dismount_mountpoint(old_mountpoint)
383
384                                if dismount:
385                                        result=self.mount_drive(profile,new_mountpoint)
386
387                if result:
388                        self.save_profiles(info)
389                        msg_log=("Edit profile: '%s' profile has been edited"%profile)
390                        self.log(msg_log)
391                        self.dprint(msg_log)
392
393               
394                return result           
395
396        #def edit_profile                       
397
398        def sync_profile(self,profile,mountpoint):
399
400                status=self.check_mountpoint_status(mountpoint)
401
402                if status["status"]:
403                        action="Dismount"
404                        result=self.dismount_mountpoint(mountpoint)
405                       
406                else:
407                        action="Mount"
408                        result=self.mount_drive(profile,mountpoint)
409
410                return {"action":action,"result":result}       
411
412        #def_sync_profile       
413
414        def log(self,msg):
415               
416                log_file=self.config_dir+"lliurex-gdrive.log"
417
418                f=open(log_file,"a+")
419                f.write(msg + '\n')
420                f.close()       
421
422        #def log                 
423
424if __name__=="__main__":
425
426        llxgd=LliurexGoogleDriveManager()
427        llxgd.mount_drives()
428       
429       
430       
431        #llxgd.save_profiles(llxgd.var)
432       
433
434
435
436
437
438
439
440
441
Note: See TracBrowser for help on using the repository browser.