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

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

encode result for send message

File size: 20.9 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
18from urllib2 import urlopen
19import string
20import subprocess
21
22class MirrorManager:
23
24
25        def __init__(self):
26                #Default values
27                self.defaultpath = '/etc/lliurex-mirror/'
28                self.debmirrorconfpath = os.path.join(self.defaultpath,'debmirror')
29                self.configpath = os.path.join(self.defaultpath,'conf')
30                self.distro="llx16"
31                self.httpd = {}
32                self.debmirrorprocess = None
33
34                self.tpl_env = Environment(loader=FileSystemLoader('/usr/share/n4d/templates/lliurex-mirror'))
35                self.update_thread=threading.Thread()
36                self.get_mirror_thread = threading.Thread()
37                self.percentage=(0,None)
38                self.exportpercentage = 0
39                self.mirrorworking = None
40                self.webserverprocess = {}
41                self.defaultmirrorinfo = {"status_mirror":"New","last_mirror_date":None,"mirror_size":0,"progress":0}
42                self.valid_chars = "-_.%s%s" % (string.ascii_letters, string.digits)
43                self.default_mirror_config = '''
44{
45        "NAME": "",
46        "BANNER": "",
47        "ORIGS" : {"1":"lliruex.net/xenial","2":"","3":""},
48        "ARCHITECTURES": [ "amd64", "i386"],
49        "SECTIONS": ["main", "main/debian-installer", "universe", "restricted", "multiverse", "partner"],
50        "MIRROR_PATH": "/net/mirror/llx16",
51        "DISTROS": ["xenial","xenial-updates","xenial-security"],
52        "IGN_GPG":1,
53        "IGN_RELEASE":0,
54        "CHK_MD5":0,
55        "CURRENT_UPDATE_OPTION":"1"
56}'''
57               
58        #def init
59       
60        def startup(self,options):
61                self.n4d_vars=objects["VariablesManager"]
62                self.variable=objects["VariablesManager"].get_variable("LLIUREXMIRROR")
63               
64               
65                if self.variable==None:
66                        try:
67                                self.n4d_vars.add_variable("LLIUREXMIRROR",{},"","Lliurex Mirror info variable","n4d-lliurex-mirror")
68                        except Exception as e:
69                                pass
70                       
71                if type(self.variable)!=type({}):
72                        self.variable={}
73               
74                try:
75                        for repo in self.get_available_mirrors()['msg']:
76                                if self.variable.has_key(repo) and self.variable[repo].has_key("status_mirror") and self.variable[repo]["status_mirror"] == "Working":
77                                        if not self.update_thread.isAlive():
78                                                self.variable[repo]["status_mirror"] = "Error"
79                                                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
80                                else:
81                                        if not self.variable.has_key(repo):
82                                                self.variable[repo] = self.defaultmirrorinfo
83                except Exception as e:
84                        pass
85        #def startup
86
87        def apt(self):
88                # executed after apt operations
89                pass
90               
91        #def apt
92       
93        # service test and backup functions #
94       
95        def test(self):
96
97                pass
98               
99        #def test
100       
101        def backup(self):
102
103                pass
104               
105        #def backup
106
107        def restore(self):
108                pass
109        #def restore
110
111        def set_cname(self):
112                #Get template
113                template = self.tpl_env.get_template("cname")
114                list_variables = {}
115               
116                list_variables = self.n4d_vars.get_variable_list(['INTERNAL_DOMAIN','HOSTNAME'])
117                for x in list_variables.keys():
118                        if list_variables[x] == None:
119                                return {'status':False,'msg':'Variable ' + x + ' not defined'}
120                       
121                #Encode vars to UTF-8
122                string_template = template.render(list_variables).encode('UTF-8')
123                #Open template file
124                fd, tmpfilepath = tempfile.mkstemp()
125                new_export_file = open(tmpfilepath,'w')
126                new_export_file.write(string_template)
127                new_export_file.close()
128                os.close(fd)
129                #Write template values
130                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/config/cname-mirror',True,'root','root','0644',False )
131               
132                return {'status':True,'msg':'Set mirror cname'}
133        #def set_cname
134       
135        def update(self,ip,distro=None,callback_args=None):
136
137                if distro==None:
138                        distro=self.distro
139       
140                if self.update_thread.is_alive():
141                        return {'status':False,'msg':'Lliurex-mirror (n4d instance) is running'}
142               
143                self.percentage=(0,None)
144                self.update_thread=threading.Thread(target=self._update,args=(ip,distro,callback_args,))
145                self.update_thread.daemon=True
146                self.update_thread.start()
147               
148                return {'status':True,'msg':'running'}
149
150        #def update
151       
152        def _update(self,ip,distro,callback_args):
153                if not self.variable.has_key(distro):
154                        self.variable[distro]=self.defaultmirrorinfo
155                # link config debmirror to correct path with distro name
156                self.variable[distro]['status_mirror'] = "Working"
157                self.variable[distro]['progress'] = 0
158                self.variable[distro]['exception_msg'] = ""
159                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
160                self.build_debmirror_config(distro)
161                if os.path.lexists('/etc/debmirror.conf'):
162                        os.remove('/etc/debmirror.conf')
163                os.symlink(os.path.join(self.debmirrorconfpath,distro),'/etc/debmirror.conf')
164                self.mirrorworking = distro
165                fd = open('/var/log/lliurex-mirror.log','a')
166                import datetime
167                fd.write("MIRROR START AT " + str(datetime.datetime.now())+ " \n")
168                fd.flush()
169                errors_found = False   
170                self.debmirrorprocess=pexpect.spawn("/usr/bin/debmirror")
171                download_packages = False
172                emergency_counter = 0
173                try:
174                        objects["ZCenterVariables"].add_pulsating_color("lliurexmirror")
175                except:
176                        pass
177                while True:
178                        try:
179                                emergency_counter += 1
180                                if emergency_counter > 100:
181                                        download_packages = True
182                                self.debmirrorprocess.expect('\n',timeout=480)
183                                line =self.debmirrorprocess.before
184
185                                fd.write(line + "\n")
186                                fd.flush()
187                                if line.find("Files to download") >= 0 :
188                                        download_packages = True
189                                line1=line.strip("\n")
190                                if download_packages:
191                                        if line1.startswith("[") and line1[5] == "]":
192                                                self.percentage=(int(line1[1:4].strip()),self.debmirrorprocess.exitstatus)
193                                                self.variable[distro]['progress'] = self.percentage[0]
194                                                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
195                                        if line1.startswith("Everything OK"):
196                                                self.percentage=(100,self.debmirrorprocess.exitstatus)
197                                                self.variable[distro]['progress'] = 100
198                                                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
199                               
200                                if errors_found:
201                                        e=Exception(line1)
202                                        raise e
203                                if line1.startswith("Errors"):
204                                        errors_found = True
205       
206
207                        except pexpect.EOF:
208                                        line1 = self.debmirrorprocess.before
209                                        if line1 != "" and line1.startswith("[") and line1[5] == "]":
210                                                        self.percentage=(int(line1[1:4].strip()),self.debmirrorprocess.exitstatus)
211                                        self.debmirrorprocess.close()
212                                        status = self.debmirrorprocess.exitstatus
213                                        self.percentage=(self.percentage[0],status)
214                                        self.variable[distro]['progress'] = self.percentage[0]
215                                        self.variable[distro]['status_mirror'] = "Ok" if status == 0 else "Error"
216                                        self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
217                                        break
218                        except Exception as e:
219                                print e
220                                self.variable[distro]['status_mirror'] = "Error"
221                                self.variable[distro]["exception_msg"] = str(e)
222                                status = self.debmirrorprocess.exitstatus
223                                self.percentage=(self.percentage[0],str(e))
224                                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
225                                break
226                fd.close()
227                if type(callback_args) != type(None):
228                        if callback_args.has_key('port'):
229                                import xmlrpclib as x
230                                c = x.ServerProxy('https://' + ip + ':9779')
231                                c.stop_webserver('','MirrorManager',callback_args['port'])
232
233                self.download_time_file(distro)
234                self.set_mirror_info(distro)
235                self.mirrorworking = None
236                try:
237                        objects["ZCenterVariables"].remove_pulsating_color("lliurexmirror")
238                except:
239                        pass
240
241        #def _update
242       
243        def is_alive(self):
244
245                return {'status':self.update_thread.is_alive(),'msg':self.mirrorworking}
246        #def is_alive
247
248        def set_mirror_info(self,distro=None):
249               
250                if distro!=None:
251                        distro=distro
252                else:
253                        distro=self.distro
254               
255                configpath = os.path.join(self.configpath, distro + ".json")
256                config = json.load(open(configpath,'r'))
257
258                mirrorpath = config["MIRROR_PATH"]
259                #self.n4d_vars.set_variable("ZEROCENTERINTERNAL",self.internal_variable)
260               
261                MIRROR_DATE=datetime.date.today().strftime("%d/%m/%Y")
262                MIRROR_SIZE=self.get_size(mirrorpath)
263               
264                self.variable[distro]["last_mirror_date"]=MIRROR_DATE
265                self.variable[distro]["mirror_size"]=str(MIRROR_SIZE)
266                self.variable[distro]["progress"]=self.percentage[0]
267               
268                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
269               
270                #set_custom_text(self,app,text):
271                txt="Updated on: " + str(MIRROR_DATE)
272                txt+=" # Size: %.2fGB"%MIRROR_SIZE
273                try:
274                        objects["ZCenterVariables"].set_custom_text("lliurexmirror",txt)
275                        abstract=open('/var/log/lliurex/lliurex-mirror.log','w')
276                        abstract.write(txt+"\n")
277                        abstract.close()
278                except Exception as e:
279                        pass
280
281        #def set_mirror_info(self):
282
283        def get_size(self,start_path = '.'):
284       
285                total_size = 0
286                try:
287                        for dirpath, dirnames, filenames in os.walk(start_path):
288                                for f in filenames:
289                                        fp = os.path.join(dirpath, f)
290                                        total_size += os.path.getsize(fp)
291                                       
292                        total_size/=1024*1024*1024.0
293                        return total_size
294                except:
295                        return 0
296       
297        #def get_size(start_path = '.'):
298       
299        def search_field(self,filepath,fieldname):
300                try:
301                        f = open(filepath,'r')
302                        needle = None
303                        lines = f.readlines()
304                        for x in lines:
305                                        if re.match('\s*'+fieldname,x):
306                                                        needle = x.strip()
307                        return needle
308                except:
309                        return None
310        # def search_field
311       
312        def get_mirror_architecture(self,distro):
313
314                configpath = os.path.join(self.configpath,distro + ".json")
315                config = json.load(open(configpath,'r'))
316                if not os.path.lexists(configpath):
317                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
318
319                if "ARCHITECTURES" in config.keys():
320                        return {'status':True,'msg':config["ARCHITECTURES"] }
321
322                return {'status':False,'msg':"debmirror.conf hasn't architecture variable" }
323        #def get_mirror_architecture
324       
325        def set_mirror_architecture(self,distro,archs):
326                configpath = os.path.join(self.configpath,distro + ".json")
327               
328                config = json.load(open(configpath,'r'))
329               
330                config['ARCHITECTURES'] = archs
331
332
333                f=open(configpath,"w")
334
335                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
336                f.write(data)
337                f.close()
338
339                self.build_debmirror_config(distro)
340                return {'status':True,'msg':'set architecture'}
341               
342        #def set_mirror_architecture
343       
344        def get_mirror_orig(self,distro,option):
345
346                configpath = os.path.join(self.configpath,distro + ".json")
347                config = json.load(open(configpath,'r'))
348                if not os.path.lexists(configpath):
349                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
350
351                if "ORIGS" in config.keys():
352                        return {'status':True,'msg':config["ORIGS"][option] }
353                       
354                return {'status':False,'msg':"debmirror.conf hasn't orig variable" }   
355        #def get_mirror_from
356
357        def set_mirror_orig(self,distro,url,option):
358                if url == None:
359                        return {'status':False,'msg':'url is None'}
360                configpath = os.path.join(self.configpath, distro + ".json")
361                config = json.load(open(configpath,'r'))
362                config['ORIGS'][option] = url
363
364                f=open(configpath,"w")
365                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
366                f.write(data)
367                f.close()
368
369                self.build_debmirror_config(distro)
370                return {'status':True,'msg':'set orig'}
371        #def set_mirror_architecture
372
373        def get_option_update(self,distro):
374                configpath = os.path.join(self.configpath,distro + ".json")
375                config = json.load(open(configpath,'r'))
376                if not os.path.lexists(configpath):
377                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
378
379                if "CURRENT_UPDATE_OPTION" in config.keys():
380                        return {'status':True,'msg':config["CURRENT_UPDATE_OPTION"] }
381                       
382                return {'status':False,'msg':"debmirror.conf hasn't option update variable" }
383        #def get_option_update
384
385        def set_option_update(self,distro,option):
386                configpath = os.path.join(self.configpath, distro + ".json")
387                config = json.load(open(configpath,'r'))
388                config['CURRENT_UPDATE_OPTION'] = str(option)
389
390                f=open(configpath,"w")
391                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
392                f.write(data)
393                f.close()
394
395                self.build_debmirror_config(distro)
396                return {'status':True,'msg':'set update option'}
397        #def set_option_update
398
399        def get_percentage(self,distro):
400                if self.variable.has_key(distro):
401                        return {'status':True,'msg':self.variable[distro]['progress']}
402                else:
403                        return {'status':False,'msg':'this repo nos has been configured'}
404        #def get_percentage
405
406
407        def build_debmirror_config(self,distro):
408                result = self.render_debmirror_config(distro)
409                string_template = result['msg']
410                f = open(os.path.join(self.debmirrorconfpath,distro),'w')
411                f.write(string_template)
412                f.close()
413        #def build_debmirror_config
414
415        def render_debmirror_config(self,arg):
416                if type(arg) == type(""):
417                        return self._render_debmirror_config_distro(arg)
418                if type(arg) == type({}):
419                        return self._render_debmirror_config_values(arg)
420        #def render_debmirror_config
421
422        def _render_debmirror_config_distro(self,distro):
423                template = self.tpl_env.get_template('debmirror.conf')
424                configpath = os.path.join(self.configpath,distro + ".json")
425                config = json.load(open(configpath,'r'))
426                return {'status':True,'msg':template.render(config).encode('utf-8')}
427        #def render_debmirror_config
428
429        def _render_debmirror_config_values(self,config):
430                template = self.tpl_env.get_template('debmirror.conf')
431                return {'status':True,'msg':template.render(config).encode('utf-8')}
432        #def _render_debmirror_config_values
433
434        def enable_webserver_into_folder(self,path):
435               
436                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
437                s.bind(('localhost', 0))
438                addr, port = s.getsockname()
439                s.close()
440                self.webserverprocess[str(port)] = Process(target=self._enable_webserver_into_folder,args=(port,path,))
441                self.webserverprocess[str(port)].start()
442                return {'status':True,'msg':port}
443        #enable_webserver_into_folder
444
445        def _enable_webserver_into_folder(self,port,path):
446                try:
447                        iface = '127.0.0.1'
448                        sock = (iface,port)
449                        proto = "HTTP/1.0"
450                        os.chdir(path)
451                        handler = SimpleHTTPRequestHandler
452                        handler.protocol_version = proto
453                        self.httpd[str(port)] = BaseHTTPServer.HTTPServer(sock,handler)
454                        self.httpd[str(port)].serve_forever()
455                except Exception, e:
456                        return None
457        #_enable_webserver_into_folder
458
459        def stop_webserver(self,port):
460                if self.webserverprocess.has_key(port):
461                        self.webserverprocess[port].terminate()
462                        self.webserverprocess.pop(port)
463                        return {'status':True,'msg':'Server stopped'}
464                return {'status':False,'msg':'Server not exists'}
465        #stop_webserver
466       
467        def set_checksum_validation(self,distro,status):
468                configpath = os.path.join(self.configpath, distro + ".json")
469                config = json.load(open(configpath,'r'))
470                config['CHK_MD5'] = status
471
472                f=open(configpath,"w")
473                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
474                f.write(data)
475                f.close()
476
477                self.build_debmirror_config(distro)
478                return {'status':True,'msg':'set checksum validation'}
479        #set_checksum_validation
480       
481        def get_checksum_validation(self,distro):
482
483                configpath = os.path.join(self.configpath,distro + ".json")
484                config = json.load(open(configpath,'r'))
485                if not os.path.lexists(configpath):
486                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
487                if "IGN_GPG" in config.keys():
488                        return {'status':True,'msg':config["CHK_MD5"] }
489
490                return {'status':False,'msg':"debmirror.conf hasn't orig variable" }
491        #get_checksum_validation
492       
493        def get_available_mirrors(self):
494                versions = os.listdir(self.configpath)
495                versions = [ version.replace('.json','') for version in versions if version.endswith('.json')]
496                return {'status':True,'msg':versions}
497
498        def stopupdate(self):
499                try:
500                        self.debmirrorprocess.terminate()
501                        return {'status':True,'msg':'debmirror stopped'}
502                except Exception as e:
503                        return {'status':False,'msg':str(e)}
504
505        def stopgetmirror(self):
506                try:
507                        self.get_mirror_process.terminate()
508                        return {'status':True,'msg':'debmirror stopped'}
509                except Exception as e:
510                        return {'status':False,'msg':str(e)}
511
512        def download_time_file(self,distro):
513               
514                configpath = os.path.join(self.configpath,distro + ".json")
515                config = json.load(open(configpath,'r'))
516                path=config["MIRROR_PATH"]
517                f="time-of-last-update"
518                dest=os.path.join(path,f)
519
520                orig_mirror=self.get_mirror_orig(distro,"1")
521                url_mirror="http://"+os.path.join(orig_mirror['msg'],f)
522
523                return self.get_time_file(url_mirror,dest)
524
525        # # def download_time_file                     
526
527               
528        def get_time_file(self,url,dest):
529               
530                try:
531                        r=urlopen(url)
532                        f=open(dest,"wb")
533                        f.write(r.read())
534                        f.close()
535                        r.close()
536                        return {'status':True,'msg':dest + 'successfully downloaded.'}
537               
538                except Exception as e:
539                        return {'status':False,'msg':'Error downloading' + dest + ':' + str(e)}                 
540
541        # def get_time_file             
542
543        def is_update_available(self,distro):
544
545                configpath = os.path.join(self.configpath,distro + ".json")
546                config = json.load(open(configpath,'r'))
547                path = config["MIRROR_PATH"]
548                file_time_name = "time-of-last-update"
549                file_local_mirror = os.path.join(path,file_time_name)
550
551               
552                if os.path.isfile(file_local_mirror):
553                        url_pool = "http://"+os.path.join(config["ORIGS"]['1'],file_time_name)
554                        file_pool = os.path.join("/tmp",file_time_name)
555
556                        exist_file_pool = self.get_time_file(url_pool,file_pool)
557                        if exist_file_pool['status']:
558                                file_local_mirror_content=open(file_local_mirror,"r")
559                                file_local_miror_datetime=(file_local_mirror_content.readline().strip()).split("_")
560                                file_pool_content=open(file_pool,'r')
561                                file_pool_datetime=(file_pool_content.readline().strip()).split("_")
562                                file_local_mirror_content.close()
563                                file_pool_content.close()
564
565                                date_local_mirror=datetime.datetime.strptime(file_local_miror_datetime[0],"%Y/%m/%d")
566                                date_pool=datetime.datetime.strptime(file_pool_datetime[0],"%Y/%m/%d")
567
568                                if date_local_mirror==date_pool:
569                                        time_local_mirror=datetime.datetime.strptime(file_local_miror_datetime[1],"%H:%M")     
570                                        time_pool=datetime.datetime.strptime(file_pool_datetime[1],"%H:%M")
571
572                                        if time_local_mirror<time_pool:
573                                                return {'status':False,'msg':'Mirror not updated','action':'update'}
574                                        else:
575                                                return {'status':True,'msg':'Mirror is updated','action':'nothing'}
576
577                                elif date_local_mirror<date_pool:
578                                        return {'status':False,'msg':'Mirror not updated','action':'update'}
579                                else:
580                                        return {'status':True,'msg':'Mirror is updated','action':'nothing'}     
581                        else:
582                                return {'status':False,'msg':exist_file_pool['msg'],'action':'nothing'} 
583
584                else:
585                        return {'status':False,'msg':file_local_mirror + ' does not exist.','action':'nothing'}
586
587        # def is_update_available
588
589        def new_mirror_config(self,config):
590                name = config["NAME"].lower().strip()
591                name = ''.join(c for c in name if c in self.valid_chars)
592
593                # Checks
594                if name == "":
595                        return {'status':False,'msg':"Name can't void"}
596                while True:
597                        newconfigpath = os.path.join(self.configpath,name + '.json')
598                        if not os.path.lexists(newconfigpath):
599                                break
600                        name = name + "1"
601
602                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
603                f = open(newconfigpath,'w')
604                f.write(data)
605                f.close()
606                self.variable[name] = self.defaultmirrorinfo
607                return {'status':True,'msg':name}
608        #def new_mirror_config
609
610        def get_all_configs(self):
611                versions = os.listdir(self.configpath)
612                allconfigs = {}
613                for version in versions:
614                        configfile = os.path.join(self.configpath,version)
615                        f = open(configfile,'r')
616                        allconfigs[version.replace('.json','')] = json.load(f)
617                        f.close()
618                return {'status':True,'msg':allconfigs}
619        #def get_all_configs
620
621        def update_mirror_config(self,mirror,config):
622                configpath = os.path.join(self.configpath,mirror + ".json")
623
624                f=open(configpath,"w")
625
626                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
627                f.write(data)
628                f.close()
629
630                return {'status':True,'msg':'Updated config'}
631        #def update_mirror_config
632
633        def get_client_ip(self,ip):
634                return {'status':True,'msg':ip}
635        #def get_client_ip
636
637        def is_alive_get_mirror(self):
638                return {'status':self.get_mirror_thread.is_alive(),'msg':self.exportpercentage}
639        #def is_alive_get_mirror
640
641        def get_mirror(self,config_path,callback_args):
642                self.get_mirror_thread = threading.Thread(target=self._get_mirror,args=(config_path,callback_args,))
643                self.get_mirror_thread.daemon = True
644                self.get_mirror_thread.start()
645        #def get_mirror
646
647        def _get_mirror(self,config_path,callback_args):
648                self.get_mirror_process = pexpect.spawn("/usr/bin/debmirror --config-file="+config_path)
649                while True:
650                        try:
651                                self.get_mirror_process.expect('\n')
652                                line =self.get_mirror_process.before
653                                line1=line.strip("\n")
654                                if line1.startswith("[") and line1[5] == "]":
655                                        self.exportpercentage = (int(line1[1:4].strip()),self.get_mirror_process.exitstatus)
656                        except pexpect.EOF:
657                                        line1 = self.get_mirror_process.before
658                                        if line1 != "" and line1.startswith("[") and line1[5] == "]":
659                                                        self.exportpercentage=(int(line1[1:4].strip()),self.get_mirror_process.exitstatus)
660                                        self.get_mirror_process.close()
661                                        status = self.get_mirror_process.exitstatus
662                                        self.exportpercentage=(self.exportpercentage[0],status)
663                                        break
664                        except Exception as e:
665                                break
666                if callback_args.has_key('port') and callback_args.has_key('ip'):
667                        import xmlrpclib as x
668                        c = x.ServerProxy('https://' + callback_args['ip'] + ':9779')
669                        c.stop_webserver('','MirrorManager',callback_args['port'])
670        #def _get
671
672        def get_last_log(self):
673                import base64
674                p = subprocess.Popen('lliurex-mirror-get-last-log',stdout=subprocess.PIPE)
675                path = p.communicate()[0].strip()
676                f = open(path,'r')
677                content = f.readlines()
678                onelinecontent = ''.join(content)
679                return {'status':True,'msg':base64.b64encode(onelinecontent)}
680
681
682
Note: See TracBrowser for help on using the repository browser.