source: lliurex-mirror/trunk/fuentes/n4d-lliurex-mirror.install/usr/share/n4d/python-plugins/MirrorManager.py @ 2042

Last change on this file since 2042 was 2042, checked in by kbut, 3 years ago

wih

File size: 10.8 KB
Line 
1from jinja2 import Environment
2from jinja2.loaders import FileSystemLoader
3from jinja2 import Template
4
5import tempfile
6
7import os
8import threading
9import datetime
10import pexpect
11import re
12import json
13
14import BaseHTTPServer
15from SimpleHTTPServer import SimpleHTTPRequestHandler
16from multiprocessing import Process
17import socket
18
19
20class MirrorManager:
21
22
23        def __init__(self):
24                #Default values
25                self.defaultpath = '/etc/lliurex-mirror/'
26                self.debmirrorconfpath = os.path.join(self.defaultpath,'debmirror')
27                self.configpath = os.path.join(self.defaultpath,'conf')
28                self.distro="llx16"
29                self.httpd = None
30                self.debmirrorprocess = None
31
32                self.tpl_env = Environment(loader=FileSystemLoader('/usr/share/n4d/templates/lliurex-mirror'))
33                self.update_thread=threading.Thread()
34                self.percentage=(0,None)
35                self.webserverprocess = None
36               
37        #def init
38       
39        def startup(self,options):
40                self.n4d_vars=objects["VariablesManager"]
41                self.variable=objects["VariablesManager"].get_variable("LLIUREXMIRROR")
42               
43               
44                if self.variable==None:
45                        try:
46                                self.n4d_vars.add_variable("LLIUREXMIRROR",{"internal":{}},"","Lliurex Mirror info variable","n4d-lliurex-mirror")
47                        except Exception as e:
48                                pass
49                       
50                if type(self.variable)!=type({}):
51                        self.variable={}
52                        self.variable["internal"]={}
53               
54                if self.variable["internal"].has_key("status_mirror") and self.variable["internal"]["status_mirror"] == "Working":
55                        if not self.update_thread.isAlive():
56                                self.variable["internal"]['status_mirror'] = "Error"
57                                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
58
59        #def startup
60
61        def apt(self):
62                # executed after apt operations
63                pass
64               
65        #def apt
66       
67        # service test and backup functions #
68       
69        def test(self):
70
71                pass
72               
73        #def test
74       
75        def backup(self):
76
77                pass
78               
79        #def backup
80
81        def restore(self):
82                pass
83        #def restore
84
85        def set_cname(self):
86                #Get template
87                template = self.tpl_env.get_template("cname")
88                list_variables = {}
89               
90                list_variables = self.n4d_vars.get_variable_list(['INTERNAL_DOMAIN','HOSTNAME'])
91                for x in list_variables.keys():
92                        if list_variables[x] == None:
93                                return {'status':False,'msg':'Variable ' + x + ' not defined'}
94                       
95                #Encode vars to UTF-8
96                string_template = template.render(list_variables).encode('UTF-8')
97                #Open template file
98                fd, tmpfilepath = tempfile.mkstemp()
99                new_export_file = open(tmpfilepath,'w')
100                new_export_file.write(string_template)
101                new_export_file.close()
102                os.close(fd)
103                #Write template values
104                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/config/cname-mirror',True,'root','root','0644',False )
105               
106                return {'status':True,'msg':'Set mirror cname'}
107        #def set_cname
108       
109        def update(self,distro=None):
110
111                if distro==None:
112                        distro=self.distro
113       
114                if self.update_thread.is_alive():
115                        return {'status':False,'msg':'Lliurex-mirror (n4d instance) is running'}
116               
117                self.percentage=(0,None)
118                self.update_thread=threading.Thread(target=self._update,args=(distro,))
119                self.update_thread.daemon=True
120                self.update_thread.start()
121               
122                return {'status':True,'msg':'running'}
123
124        #def update
125       
126        def _update(self,distro):
127
128                # link config debmirror to correct path with distro name
129                self.variable["internal"]['status_mirror'] = "Working"
130                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
131                filelog = open('/var/log/lliurex-mirror.log','w')
132                self.build_debmirror_config(distro)
133                os.remove('/etc/debmirror.conf')
134                os.symlink(os.path.join(self.debmirrorconfpath,distro),'/etc/debmirror.conf')
135                self.debmirrorprocess=pexpect.spawn("/usr/bin/debmirror")
136                try:
137                        objects["ZCenterVariables"].add_pulsating_color("lliurexmirror")
138                except:
139                        pass
140                while True:
141                        try:
142                                self.debmirrorprocess.expect('\n')
143                                line =self.debmirrorprocess.before
144                                filelog.write(line)
145                                line1=line.strip("\n")
146                                if line1.startswith("[") and line1[5] == "]":
147                                        self.percentage=(int(line1[1:4].strip()),self.debmirrorprocess.exitstatus)
148                        except pexpect.EOF:
149                                        line1 = self.debmirrorprocess.before
150                                        if line1 != "" and line1.startswith("[") and line1[5] == "]":
151                                                        self.percentage=(int(line1[1:4].strip()),self.debmirrorprocess.exitstatus)
152                                        filelog.write(line1)
153                                        self.debmirrorprocess.close()
154                                        status = self.debmirrorprocess.exitstatus
155                                        self.percentage=(self.percentage[0],status)
156
157                                        self.variable["internal"]['status_mirror'] = "Ok" if status == 0 else "Error"
158                                        self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
159                                        break
160                        except Exception as e:
161                                self.variable["internal"]['status_mirror'] = "Error"
162                                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
163                                break
164                filelog.close()
165                self.set_mirror_info(distro)
166
167                try:
168                        objects["ZCenterVariables"].remove_pulsating_color("lliurexmirror")
169                except:
170                        pass
171
172        #def _update
173       
174        def is_alive(self):
175                return {'status':self.update_thread.is_alive(),'msg':''}
176        #def is_alive
177
178        def set_mirror_info(self,distro=None):
179               
180                if distro!=None:
181                        distro=distro
182                else:
183                        distro=self.distro
184               
185                configpath = os.path.join(self.configpath, distro + ".json")
186                config = json.load(open(configpath,'r'))
187
188                mirrorpath = config["MIRRORPATH"]
189                #self.n4d_vars.set_variable("ZEROCENTERINTERNAL",self.internal_variable)
190               
191                MIRROR_DATE=datetime.date.today().strftime("%d/%m/%Y")
192                MIRROR_SIZE=self.get_size(mirrorpath)
193               
194                self.variable["internal"]["last_mirror_date"]=MIRROR_DATE
195                self.variable["internal"]["mirror_size"]=str(MIRROR_SIZE)
196                self.variable["internal"]["progress"]=self.percentage[0]
197               
198                print self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
199               
200                #set_custom_text(self,app,text):
201                txt="Updated on: " + str(MIRROR_DATE)
202                txt+=" # Size: %.2fGB"%MIRROR_SIZE
203                try:
204                        objects["ZCenterVariables"].set_custom_text("lliurexmirror",txt)
205                        abstract=open('/var/log/lliurex/lliurex-mirror.log','w')
206                        abstract.write(txt+"\n")
207                        abstract.close()
208                except Exception as e:
209                        pass
210
211        #def set_mirror_info(self):
212
213        def get_size(self,start_path = '.'):
214       
215                total_size = 0
216                try:
217                        for dirpath, dirnames, filenames in os.walk(start_path):
218                                for f in filenames:
219                                        fp = os.path.join(dirpath, f)
220                                        total_size += os.path.getsize(fp)
221                                       
222                        total_size/=1024*1024*1024.0
223                        return total_size
224                except:
225                        return 0
226       
227        #def get_size(start_path = '.'):
228       
229        def search_field(self,filepath,fieldname):
230                try:
231                        f = open(filepath,'r')
232                        needle = None
233                        lines = f.readlines()
234                        for x in lines:
235                                        if re.match('\s*'+fieldname,x):
236                                                        needle = x.strip()
237                        return needle
238                except:
239                        return None
240        # def search_field
241       
242        def get_mirror_architecture(self,distro):
243
244                configpath = os.path.join(self.configpath,distro + ".json")
245                config = json.load(open(configpath,'r'))
246                if not os.path.exists(configpath):
247                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
248
249                if "ARCHITECTURES" in config.keys():
250                        return {'status':True,'msg':config["ARCHITECTURES"] }
251
252                return {'status':False,'msg':"debmirror.conf hasn't architecture variable" }
253        #def get_mirror_architecture
254       
255        def set_mirror_architecture(self,distro,archs):
256                configpath = os.path.join(self.configpath,distro + ".json")
257               
258                config = json.load(open(configpath,'r'))
259               
260                config['ARCHITECTURES'] = archs
261
262
263                f=open(configpath,"w")
264
265                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
266                f.write(data)
267                f.close()
268
269                self.build_debmirror_config(distro)
270                return {'status':True,'msg':'set architecture'}
271               
272        #def set_mirror_architecture
273       
274        def get_mirror_orig(self,distro):
275
276                configpath = os.path.join(self.configpath,distro + ".json")
277                config = json.load(open(configpath,'r'))
278                if not os.path.exists(configpath):
279                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
280
281                if "URL" in config.keys():
282                        return {'status':True,'msg':config["URL"] }
283                       
284                return {'status':False,'msg':"debmirror.conf hasn't orig variable" }           
285        #def get_mirror_from
286
287        def set_mirror_orig(self,distro,url):
288                configpath = os.path.join(self.configpath, distro + ".json")
289                config = json.load(open(configpath,'r'))
290                config['URL'] = url
291
292                f=open(configpath,"w")
293                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
294                f.write(data)
295                f.close()
296
297                self.build_debmirror_config(distro)
298                return {'status':True,'msg':'set orig'}
299        #def set_mirror_architecture
300
301        def get_percentage(self):
302                if not self.is_alive():
303                        return {'status':True,'msg':self.variable['internal']['progress']};
304                return {'status':True,'msg':self.percentage}
305
306        def build_debmirror_config(self,distro):
307                template = self.tpl_env.get_template('debmirror.conf')
308                configpath = os.path.join(self.configpath,distro + ".json")
309                config = json.load(open(configpath,'r'))
310                string_template = template.render(config).encode('utf-8')
311                f = open(os.path.join(self.debmirrorconfpath,distro),'w')
312                f.write(string_template)
313                f.close()
314        #def build_debmirror_config
315       
316        def enable_webserver_into_folder(self,path):
317                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
318                s.bind(('localhost', 0))
319                addr, port = s.getsockname()
320                s.close()
321                self.webserverprocess = Process(target=self._enable_webserver_into_folder,args=(port,path,))
322                self.webserverprocess.start()
323                return {'status':True,'msg':port}
324        #enable_webserver_into_folder
325
326        def _enable_webserver_into_folder(self,port,path):
327                try:
328                        import os
329                        iface = '127.0.0.1'
330                        sock = (iface,port)
331                        proto = "HTTP/1.0"
332                        os.chdir(path)
333                        handler = SimpleHTTPRequestHandler
334                        handler.protocol_version = proto
335                        self.httpd = BaseHTTPServer.HTTPServer(sock,handler)
336                        self.httpd.serve_forever()
337                except Exception, e:
338                        return None
339        #_enable_webserver_into_folder
340
341        def stop_webserver(self):
342                if self.webserverprocess != None:
343                        self.webserverprocess.terminate()
344                return {'status':True,'msg':'Server stopped'}
345        #stop_webserver
346       
347        def set_checksum_validation(self,distro,status):
348                configpath = os.path.join(self.configpath, distro + ".json")
349                config = json.load(open(configpath,'r'))
350                config['CHK_MD5'] = status
351
352                f=open(configpath,"w")
353                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
354                f.write(data)
355                f.close()
356
357                self.build_debmirror_config(distro)
358                return {'status':True,'msg':'set checksum validation'}
359        #set_checksum_validation
360       
361        def get_checksum_validation(self,distro):
362
363                configpath = os.path.join(self.configpath,distro + ".json")
364                config = json.load(open(configpath,'r'))
365                if not os.path.exists(configpath):
366                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
367                if "IGN_GPG" in config.keys():
368                        return {'status':True,'msg':config["CHK_MD5"] }
369
370                return {'status':False,'msg':"debmirror.conf hasn't orig variable" }
371        #get_checksum_validation
372       
373        def get_available_mirrors(self):
374                versions = os.listdir(self.configpath)
375                versions = [ version.replace('.json','') for version in versions if version.endswith('.json')]
376                return {'status':True,'msg':versions}
377
378        def stopupdate(self):
379                try:
380                        self.debmirrorprocess.terminate()
381                        return {'status':true,'msg':'debmirror stopped'}
382                except Exception as e:
383                        return {'status':False,'msg':str(e)}
384
Note: See TracBrowser for help on using the repository browser.