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

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

WIP in check connection

  • Property svn:executable set to *
File size: 10.8 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
28                self.read_conf()
29               
30
31        #def init
32
33        def create_conf(self):
34
35                if not os.path.exists(self.config_dir):
36                        os.makedirs(self.config_dir)
37
38                var={}
39                # var["default"]={}
40                # var["default"]["email"]=""
41                # var["default"]["mountpoint"]=""
42                # var["default"]["automount"]=""
43
44                f=open(self.config_file,"w")
45                data=unicode(json.dumps(var,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
46
47                f.write(data)
48                f.close()
49
50                msg_log="Creating conf..."
51                self.dprint(msg_log)
52               
53
54        #def create_conf
55       
56        def read_conf(self):
57               
58                if not os.path.exists(self.config_file):
59                        self.create_conf()
60               
61                log_msg="------------------------------------------\n"+"LLIUREX-GDRIVE STARTING AT: " + datetime.datetime.today().strftime("%d/%m/%y %H:%M:%S") +"\n------------------------------------------"
62                self.log(log_msg)
63                msg_log="Init: Reading conf..."
64                self.dprint(msg_log)
65                self.log(msg_log)
66                       
67                f=open(self.config_file)
68                try:
69                        self.profiles_config=json.load(f)
70                except:
71                        self.profiles_config={}
72                f.close()
73               
74        #def read_conf
75       
76        def check_config(self,profile):
77               
78                path=GDRIVE_CONFIG_DIR+profile+"/state"
79                profile=profile.encode("utf-8")
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                                return False
91                       
92                        msg_log="Check config: '%s' yet configured"%profile
93                        self.dprint(msg_log)
94                        self.log(msg_log)
95                        return True
96
97                else:
98                        msg_log="Check config: '%s' not yet create"%profile
99                        self.dprint(msg_log)
100                        self.log(msg_log)
101                        return False
102
103               
104        #def check_config
105
106        def check_google_connection(self):
107
108                try:
109                        print "vamos a ver"
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_connections           
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                for profile in self.profiles_config:
197                        automount=self.profiles_config[profile]["automount"]
198                        if automount:
199                                mountpoint=self.profiles_config[profile]["mountpoint"]
200                                profile=profile.encode("utf-8")
201                                mountpoint=mountpoint.encode("utf-8")
202                                self.mount_drive(profile,mountpoint)
203                                               
204               
205        #def mount_drives
206
207        def dprint(self,msg):
208               
209                if DEBUG:
210                        print("[LGDM] %s"%msg)
211                       
212        #def dprint
213       
214       
215        def save_profiles(self,info):
216               
217                self.profiles_config=info
218               
219                f=open(self.config_file,"w")
220                #data=json.dumps(info,indent=4,encoding="utf-8",ensure_ascii=False)
221                data=unicode(json.dumps(info,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
222                f.write(data)
223                f.close()
224
225        #def save_profiles     
226
227        def check_mountpoint_status(self,mountpoint):
228
229                mountpoint_size=""
230                mountpoint_used=""
231                mountpoint_available=""
232                mountpoint_per=""
233                tmp=[]
234
235
236                command='df -h | grep "google-drive-ocamlfuse" | grep ' +mountpoint+'$' 
237                       
238                p=subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
239                poutput,perror=p.communicate()
240
241                if len(poutput)>0:
242                        status=True
243
244                        for item in poutput.split(" "):
245                                if len(item)>1:
246                                        tmp.append(item)
247
248                        mountpoint_size=tmp[1]
249                        mountpoint_used=tmp[2]
250                        mountpoint_available=tmp[3]
251                        mountpoint_per=tmp[4]
252
253                else:
254                        status=False
255               
256                return {"status":status,"size":mountpoint_size,"used":mountpoint_used,"available":mountpoint_available,"used%":mountpoint_per}         
257               
258        #def check_mountpoint_status   
259               
260        def check_profile_info(self,profile,mountpoint,edition):
261       
262                '''
263                        code=0: Form OK
264                        code=1: Profile empty
265                        code=2: Profile with blanck spaces
266                        code=3: Profile duplicate
267                        code=4: Mountpoint duplicate
268
269                '''     
270                #profile=profile.decode("utf-8")
271                if not edition:
272
273                       
274                        # type(unicode) ==> encode("utf-8")
275                        # type(str) ==> decode("utf-8")
276                       
277
278                        if profile=="":
279                                return {"result":False,"code":1}
280
281                        if ' ' in profile:
282                                return {"result":False,"code":2}
283       
284                        else:
285                                for item in self.profiles_config:
286                                        if profile==item:
287                                                return {"result":False,"code":3}
288
289                for item in self.profiles_config:
290                        if profile!=item:
291                                if mountpoint==self.profiles_config[item]["mountpoint"]:
292                                        return {"result":False,"code":4}
293
294                return {"result":True,"code":0}                                                         
295       
296        #def check_profile_info
297
298        def create_profile(self,profile):
299
300                #profile=unicode(profile).encode("utf-8")
301                path=GDRIVE_CONFIG_DIR+profile+"/config"
302
303                if not self.check_config(profile):
304                        os.system("google-drive-ocamlfuse -label %s"%unicode(profile).encode("utf-8"))
305                        msg_log=("'%s' profile has been create")%profile
306                        self.log(msg_log)
307                        self.dprint(msg_log)
308
309                        if os.path.exists(GDRIVE_CONFIG_DIR+profile):
310                                shutil.copy(LLIUREX_CONFIG_FILE,path )
311               
312                return True
313                               
314                       
315        #def create_profile
316
317        def create_mountpoint(self,info,profile):
318
319                mountpoint=info[profile]["mountpoint"]
320
321                result=self.mount_drive(profile,mountpoint)
322               
323                if result["result"]:
324                        self.save_profiles(info)
325                else:
326                        if profile !="":
327                                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
328                                        shutil.rmtree(os.path.join(GDRIVE_CONFIG_DIR+profile))
329                                        self.dprint("'%s' profile has been delete"%profile)
330                       
331                return result
332
333        #def create_mountpoint 
334
335        def dismount_mountpoint(self,mountpoint):
336
337                cmd='fusermount -u ' + mountpoint
338                p=subprocess.Popen(cmd, shell=True,stdout=subprocess.PIPE, stderr=subprocess.PIPE)
339                poutput,perror=p.communicate()
340
341                mountpoint=mountpoint.encode("utf-8")
342                if len(perror)>0:
343                        msg_log="Dismount mountpoint: Error dismounted '%s': '%s'"%(mountpoint,str(perror))
344                        self.dprint(msg_log)
345                        self.log(msg_log)
346                        result=False
347                        code=7
348                else:
349                        msg_log="Dismount mountpoint:'%s' mountpoint has been dismounted"%mountpoint
350                        self.dprint(msg_log)
351                        self.log(msg_log)
352                        result=True
353                        code=0                                 
354
355                return {"result":result,"code":code}
356
357        #def dismount_mountpoint       
358
359        def delete_profile(self,info,profile):
360
361                dismount={}
362                dismount["result"]=True
363
364                #profile=str(profile)
365                mountpoint=self.profiles_config[profile]["mountpoint"]
366               
367
368
369                if os.path.exists(GDRIVE_CONFIG_DIR+profile):
370                        is_mountpoint_mounted=self.check_mountpoint_status(mountpoint)
371
372                        if is_mountpoint_mounted["status"]:
373                                dismount=self.dismount_mountpoint(mountpoint)
374
375                        if dismount["result"]:
376                                if profile!="":
377                                        shutil.rmtree(os.path.join(GDRIVE_CONFIG_DIR+profile))
378                                        msg_log="Delete profile: '%s' profile has been delete"%profile.encode("utf-8")
379                                        self.log(msg_log)
380                                        self.dprint(msg_log)
381                                self.save_profiles(info)
382                                return dismount                 
383
384                else:
385                        self.save_profiles(info)
386                        msg_log="Delete profile: '%s' GDrive profile path does not exist"%profile.encode("utf-8")
387                        self.log(msg_log)
388                        self.dprint(msg_log)
389                       
390                        return {"result":True,"code":0}
391               
392       
393        # delete_profile       
394
395       
396        def edit_profile(self,info,profile):
397
398                result={}
399                result["result"]=True
400                result["code"]=0
401
402                old_mountpoint=self.profiles_config[profile]["mountpoint"]
403                old_automount=self.profiles_config[profile]["automount"]
404                new_mountpoint=info[profile]["mountpoint"]
405                new_automount=info[profile]["automount"]
406
407                if old_mountpoint!=new_mountpoint:
408                        status=self.check_mountpoint_status(old_mountpoint)
409
410                        if status["status"]:
411                                result=self.dismount_mountpoint(old_mountpoint)
412
413                                if result["result"]:
414                                        result=self.mount_drive(profile,new_mountpoint)
415                                       
416
417                if result["result"]:
418                        self.save_profiles(info)
419                        msg_log="Edit profile: '%s' profile has been edited"%profile.encode("utf-8")
420                        self.log(msg_log)
421                        self.dprint(msg_log)
422
423               
424                return {"result":result["result"],"code":result["code"]}               
425
426        #def edit_profile                       
427
428        def sync_profile(self,profile,mountpoint):
429
430                status=self.check_mountpoint_status(mountpoint)
431
432                if status["status"]:
433                        action="Dismount"
434                        result=self.dismount_mountpoint(mountpoint)
435                       
436                else:
437                        action="Mount"
438                        result=self.mount_drive(profile,mountpoint)
439
440                return {"action":action,"result":result["result"],"code":result["code"]}       
441
442        #def_sync_profile       
443
444        def log(self,msg):
445               
446                log_file=self.config_dir+"lliurex-gdrive.log"
447
448                f=open(log_file,"a+")
449                f.write(msg + '\n')
450                f.close()       
451
452        #def log                 
453
454if __name__=="__main__":
455
456        llxgd=LliurexGoogleDriveManager()
457        llxgd.mount_drives()
458       
459       
460       
461        #llxgd.save_profiles(llxgd.var)
462       
463
464
465
466
467
468
469
470
471
Note: See TracBrowser for help on using the repository browser.