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

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

wip

File size: 21.3 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                return {'status':self.update_thread.is_alive(),'msg':self.mirrorworking}
245        #def is_alive
246
247        def set_mirror_info(self,distro=None):
248               
249                if distro!=None:
250                        distro=distro
251                else:
252                        distro=self.distro
253               
254                configpath = os.path.join(self.configpath, distro + ".json")
255                config = json.load(open(configpath,'r'))
256
257                mirrorpath = config["MIRROR_PATH"]
258                #self.n4d_vars.set_variable("ZEROCENTERINTERNAL",self.internal_variable)
259               
260                MIRROR_DATE=datetime.date.today().strftime("%d/%m/%Y")
261                MIRROR_SIZE=self.get_size(mirrorpath)
262               
263                self.variable[distro]["last_mirror_date"]=MIRROR_DATE
264                self.variable[distro]["mirror_size"]=str(MIRROR_SIZE)
265                self.variable[distro]["progress"]=self.percentage[0]
266               
267                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
268               
269                #set_custom_text(self,app,text):
270                txt="Updated on: " + str(MIRROR_DATE)
271                txt+=" # Size: %.2fGB"%MIRROR_SIZE
272                try:
273                        objects["ZCenterVariables"].set_custom_text("lliurexmirror",txt)
274                        abstract=open('/var/log/lliurex/lliurex-mirror.log','w')
275                        abstract.write(txt+"\n")
276                        abstract.close()
277                except Exception as e:
278                        pass
279
280        #def set_mirror_info(self):
281
282        def update_size_info(self,distro):
283                if distro!=None:
284                        distro=distro
285                else:
286                        distro=self.distro
287               
288                configpath = os.path.join(self.configpath, distro + ".json")
289                config = json.load(open(configpath,'r'))
290
291                mirrorpath = config["MIRROR_PATH"]
292                MIRROR_SIZE=self.get_size(mirrorpath)
293                self.variable[distro]["mirror_size"]=str(MIRROR_SIZE)
294                self.n4d_vars.set_variable("LLIUREXMIRROR",self.variable)
295                return {'status':True,'msg':MIRROR_SIZE}
296
297
298        def get_size(self,start_path = '.'):
299       
300                total_size = 0
301                try:
302                        for dirpath, dirnames, filenames in os.walk(start_path):
303                                for f in filenames:
304                                        fp = os.path.join(dirpath, f)
305                                        total_size += os.path.getsize(fp)
306                                       
307                        total_size/=1024*1024*1024.0
308                        return total_size
309                except:
310                        return 0
311       
312        #def get_size(start_path = '.'):
313       
314        def search_field(self,filepath,fieldname):
315                try:
316                        f = open(filepath,'r')
317                        needle = None
318                        lines = f.readlines()
319                        for x in lines:
320                                        if re.match('\s*'+fieldname,x):
321                                                        needle = x.strip()
322                        return needle
323                except:
324                        return None
325        # def search_field
326       
327        def get_mirror_architecture(self,distro):
328
329                configpath = os.path.join(self.configpath,distro + ".json")
330                config = json.load(open(configpath,'r'))
331                if not os.path.lexists(configpath):
332                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
333
334                if "ARCHITECTURES" in config.keys():
335                        return {'status':True,'msg':config["ARCHITECTURES"] }
336
337                return {'status':False,'msg':"debmirror.conf hasn't architecture variable" }
338        #def get_mirror_architecture
339       
340        def set_mirror_architecture(self,distro,archs):
341                configpath = os.path.join(self.configpath,distro + ".json")
342               
343                config = json.load(open(configpath,'r'))
344               
345                config['ARCHITECTURES'] = archs
346
347
348                f=open(configpath,"w")
349
350                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
351                f.write(data)
352                f.close()
353
354                self.build_debmirror_config(distro)
355                return {'status':True,'msg':'set architecture'}
356               
357        #def set_mirror_architecture
358       
359        def get_mirror_orig(self,distro,option):
360
361                configpath = os.path.join(self.configpath,distro + ".json")
362                config = json.load(open(configpath,'r'))
363                if not os.path.lexists(configpath):
364                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
365
366                if "ORIGS" in config.keys():
367                        return {'status':True,'msg':config["ORIGS"][option] }
368                       
369                return {'status':False,'msg':"debmirror.conf hasn't orig variable" }   
370        #def get_mirror_from
371
372        def set_mirror_orig(self,distro,url,option):
373                if url == None:
374                        return {'status':False,'msg':'url is None'}
375                configpath = os.path.join(self.configpath, distro + ".json")
376                config = json.load(open(configpath,'r'))
377                config['ORIGS'][option] = url
378
379                f=open(configpath,"w")
380                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
381                f.write(data)
382                f.close()
383
384                self.build_debmirror_config(distro)
385                return {'status':True,'msg':'set orig'}
386        #def set_mirror_architecture
387
388        def get_option_update(self,distro):
389                configpath = os.path.join(self.configpath,distro + ".json")
390                config = json.load(open(configpath,'r'))
391                if not os.path.lexists(configpath):
392                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
393
394                if "CURRENT_UPDATE_OPTION" in config.keys():
395                        return {'status':True,'msg':config["CURRENT_UPDATE_OPTION"] }
396                       
397                return {'status':False,'msg':"debmirror.conf hasn't option update variable" }
398        #def get_option_update
399
400        def set_option_update(self,distro,option):
401                configpath = os.path.join(self.configpath, distro + ".json")
402                config = json.load(open(configpath,'r'))
403                config['CURRENT_UPDATE_OPTION'] = str(option)
404
405                f=open(configpath,"w")
406                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
407                f.write(data)
408                f.close()
409
410                self.build_debmirror_config(distro)
411                return {'status':True,'msg':'set update option'}
412        #def set_option_update
413
414        def get_percentage(self,distro):
415                if self.variable.has_key(distro):
416                        return {'status':True,'msg':self.variable[distro]['progress']}
417                else:
418                        return {'status':False,'msg':'this repo nos has been configured'}
419        #def get_percentage
420
421
422        def build_debmirror_config(self,distro):
423                result = self.render_debmirror_config(distro)
424                string_template = result['msg']
425                f = open(os.path.join(self.debmirrorconfpath,distro),'w')
426                f.write(string_template)
427                f.close()
428        #def build_debmirror_config
429
430        def render_debmirror_config(self,arg):
431                if type(arg) == type(""):
432                        return self._render_debmirror_config_distro(arg)
433                if type(arg) == type({}):
434                        return self._render_debmirror_config_values(arg)
435        #def render_debmirror_config
436
437        def _render_debmirror_config_distro(self,distro):
438                template = self.tpl_env.get_template('debmirror.conf')
439                configpath = os.path.join(self.configpath,distro + ".json")
440                config = json.load(open(configpath,'r'))
441                return {'status':True,'msg':template.render(config).encode('utf-8')}
442        #def render_debmirror_config
443
444        def _render_debmirror_config_values(self,config):
445                template = self.tpl_env.get_template('debmirror.conf')
446                return {'status':True,'msg':template.render(config).encode('utf-8')}
447        #def _render_debmirror_config_values
448
449        def enable_webserver_into_folder(self,path):
450               
451                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
452                s.bind(('localhost', 0))
453                addr, port = s.getsockname()
454                s.close()
455                self.webserverprocess[str(port)] = Process(target=self._enable_webserver_into_folder,args=(port,path,))
456                self.webserverprocess[str(port)].start()
457                return {'status':True,'msg':port}
458        #enable_webserver_into_folder
459
460        def _enable_webserver_into_folder(self,port,path):
461                try:
462                        iface = '127.0.0.1'
463                        sock = (iface,port)
464                        proto = "HTTP/1.0"
465                        os.chdir(path)
466                        handler = SimpleHTTPRequestHandler
467                        handler.protocol_version = proto
468                        self.httpd[str(port)] = BaseHTTPServer.HTTPServer(sock,handler)
469                        self.httpd[str(port)].serve_forever()
470                except Exception, e:
471                        return None
472        #_enable_webserver_into_folder
473
474        def stop_webserver(self,port):
475                if self.webserverprocess.has_key(port):
476                        self.webserverprocess[port].terminate()
477                        self.webserverprocess.pop(port)
478                        return {'status':True,'msg':'Server stopped'}
479                return {'status':False,'msg':'Server not exists'}
480        #stop_webserver
481       
482        def set_checksum_validation(self,distro,status):
483                configpath = os.path.join(self.configpath, distro + ".json")
484                config = json.load(open(configpath,'r'))
485                config['CHK_MD5'] = status
486
487                f=open(configpath,"w")
488                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
489                f.write(data)
490                f.close()
491
492                self.build_debmirror_config(distro)
493                return {'status':True,'msg':'set checksum validation'}
494        #set_checksum_validation
495       
496        def get_checksum_validation(self,distro):
497
498                configpath = os.path.join(self.configpath,distro + ".json")
499                config = json.load(open(configpath,'r'))
500                if not os.path.lexists(configpath):
501                        return {'status':False,'msg':'not exists debmirror.conf to '+ distro }
502                if "IGN_GPG" in config.keys():
503                        return {'status':True,'msg':config["CHK_MD5"] }
504
505                return {'status':False,'msg':"debmirror.conf hasn't orig variable" }
506        #get_checksum_validation
507       
508        def get_available_mirrors(self):
509                versions = os.listdir(self.configpath)
510                versions = [ version.replace('.json','') for version in versions if version.endswith('.json')]
511                return {'status':True,'msg':versions}
512
513        def stopupdate(self):
514                try:
515                        self.debmirrorprocess.terminate()
516                        return {'status':True,'msg':'debmirror stopped'}
517                except Exception as e:
518                        return {'status':False,'msg':str(e)}
519
520        def stopgetmirror(self):
521                try:
522                        self.get_mirror_process.terminate()
523                        return {'status':True,'msg':'debmirror stopped'}
524                except Exception as e:
525                        return {'status':False,'msg':str(e)}
526
527        def download_time_file(self,distro):
528               
529                configpath = os.path.join(self.configpath,distro + ".json")
530                config = json.load(open(configpath,'r'))
531                path=config["MIRROR_PATH"]
532                f="time-of-last-update"
533                dest=os.path.join(path,f)
534
535                orig_mirror=self.get_mirror_orig(distro,"1")
536                url_mirror="http://"+os.path.join(orig_mirror['msg'],f)
537
538                return self.get_time_file(url_mirror,dest)
539
540        # # def download_time_file                     
541
542               
543        def get_time_file(self,url,dest):
544               
545                try:
546                        r=urlopen(url)
547                        f=open(dest,"wb")
548                        f.write(r.read())
549                        f.close()
550                        r.close()
551                        return {'status':True,'msg':dest + 'successfully downloaded.'}
552               
553                except Exception as e:
554                        return {'status':False,'msg':'Error downloading' + dest + ':' + str(e)}                 
555
556        # def get_time_file             
557
558        def is_update_available(self,distro):
559
560                configpath = os.path.join(self.configpath,distro + ".json")
561                config = json.load(open(configpath,'r'))
562                path = config["MIRROR_PATH"]
563                file_time_name = "time-of-last-update"
564                file_local_mirror = os.path.join(path,file_time_name)
565
566               
567                if os.path.isfile(file_local_mirror):
568                        url_pool = "http://"+os.path.join(config["ORIGS"]['1'],file_time_name)
569                        file_pool = os.path.join("/tmp",file_time_name)
570
571                        exist_file_pool = self.get_time_file(url_pool,file_pool)
572                        if exist_file_pool['status']:
573                                file_local_mirror_content=open(file_local_mirror,"r")
574                                file_local_miror_datetime=(file_local_mirror_content.readline().strip()).split("_")
575                                file_pool_content=open(file_pool,'r')
576                                file_pool_datetime=(file_pool_content.readline().strip()).split("_")
577                                file_local_mirror_content.close()
578                                file_pool_content.close()
579
580                                date_local_mirror=datetime.datetime.strptime(file_local_miror_datetime[0],"%Y/%m/%d")
581                                date_pool=datetime.datetime.strptime(file_pool_datetime[0],"%Y/%m/%d")
582
583                                if date_local_mirror==date_pool:
584                                        time_local_mirror=datetime.datetime.strptime(file_local_miror_datetime[1],"%H:%M")     
585                                        time_pool=datetime.datetime.strptime(file_pool_datetime[1],"%H:%M")
586
587                                        if time_local_mirror<time_pool:
588                                                return {'status':False,'msg':'Mirror not updated','action':'update'}
589                                        else:
590                                                return {'status':True,'msg':'Mirror is updated','action':'nothing'}
591
592                                elif date_local_mirror<date_pool:
593                                        return {'status':False,'msg':'Mirror not updated','action':'update'}
594                                else:
595                                        return {'status':True,'msg':'Mirror is updated','action':'nothing'}     
596                        else:
597                                return {'status':False,'msg':exist_file_pool['msg'],'action':'nothing'} 
598
599                else:
600                        return {'status':False,'msg':file_local_mirror + ' does not exist.','action':'nothing'}
601
602        # def is_update_available
603
604        def new_mirror_config(self,config):
605                name = config["NAME"].lower().strip()
606                name = ''.join(c for c in name if c in self.valid_chars)
607
608                # Checks
609                if name == "":
610                        return {'status':False,'msg':"Name can't void"}
611                while True:
612                        newconfigpath = os.path.join(self.configpath,name + '.json')
613                        if not os.path.lexists(newconfigpath):
614                                break
615                        name = name + "1"
616
617                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
618                f = open(newconfigpath,'w')
619                f.write(data)
620                f.close()
621                self.variable[name] = self.defaultmirrorinfo
622                return {'status':True,'msg':name}
623        #def new_mirror_config
624
625        def get_all_configs(self):
626                versions = os.listdir(self.configpath)
627                allconfigs = {}
628                for version in versions:
629                        configfile = os.path.join(self.configpath,version)
630                        f = open(configfile,'r')
631                        allconfigs[version.replace('.json','')] = json.load(f)
632                        f.close()
633                return {'status':True,'msg':allconfigs}
634        #def get_all_configs
635
636        def update_mirror_config(self,mirror,config):
637                configpath = os.path.join(self.configpath,mirror + ".json")
638
639                f=open(configpath,"w")
640
641                data=unicode(json.dumps(config,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
642                f.write(data)
643                f.close()
644
645                return {'status':True,'msg':'Updated config'}
646        #def update_mirror_config
647
648        def get_client_ip(self,ip):
649                return {'status':True,'msg':ip}
650        #def get_client_ip
651
652        def is_alive_get_mirror(self):
653                return {'status':self.get_mirror_thread.is_alive(),'msg':self.exportpercentage}
654        #def is_alive_get_mirror
655
656        def get_mirror(self,config_path,callback_args):
657                self.get_mirror_thread = threading.Thread(target=self._get_mirror,args=(config_path,callback_args,))
658                self.get_mirror_thread.daemon = True
659                self.get_mirror_thread.start()
660        #def get_mirror
661
662        def _get_mirror(self,config_path,callback_args):
663                self.get_mirror_process = pexpect.spawn("/usr/bin/debmirror --config-file="+config_path)
664                while True:
665                        try:
666                                self.get_mirror_process.expect('\n')
667                                line =self.get_mirror_process.before
668                                line1=line.strip("\n")
669                                if line1.startswith("[") and line1[5] == "]":
670                                        self.exportpercentage = (int(line1[1:4].strip()),self.get_mirror_process.exitstatus)
671                        except pexpect.EOF:
672                                        line1 = self.get_mirror_process.before
673                                        if line1 != "" and line1.startswith("[") and line1[5] == "]":
674                                                        self.exportpercentage=(int(line1[1:4].strip()),self.get_mirror_process.exitstatus)
675                                        self.get_mirror_process.close()
676                                        status = self.get_mirror_process.exitstatus
677                                        self.exportpercentage=(self.exportpercentage[0],status)
678                                        break
679                        except Exception as e:
680                                break
681                if callback_args.has_key('port') and callback_args.has_key('ip'):
682                        import xmlrpclib as x
683                        c = x.ServerProxy('https://' + callback_args['ip'] + ':9779')
684                        c.stop_webserver('','MirrorManager',callback_args['port'])
685        #def _get
686
687        def get_last_log(self):
688                import base64
689                p = subprocess.Popen('lliurex-mirror-get-last-log',stdout=subprocess.PIPE)
690                path = p.communicate()[0].strip()
691                f = open(path,'r')
692                content = f.readlines()
693                onelinecontent = ''.join(content)
694                return {'status':True,'msg':base64.b64encode(onelinecontent)}
695
696
697
Note: See TracBrowser for help on using the repository browser.