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

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

add variables with info into n4d vars

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