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

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

WIP in gui.Improve result of manage gdrive actions

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