source: lliurex-gdrive/trunk/fuentes/lliurex-gdrive-gui.install/usr/share/lliurex-gdrive/LliurexGoogleDriveManager.py @ 3845

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

WIP in gui

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