source: n4d-dnsmasq/trunk/fuentes/install-dnsmasq/usr/share/n4d/python-plugins/DnsmasqManager.py @ 1979

Last change on this file since 1979 was 1979, checked in by Juanma, 4 years ago

Fix centralized services in backups from trusty

File size: 24.7 KB
Line 
1# npackage example  https://svn.lliurex.net/pandora/n4d-ldap/trunk
2# jinja2 http://jinja.pocoo.org/docs/templates
3
4from jinja2 import Environment
5from jinja2.loaders import FileSystemLoader
6from jinja2 import Template
7import tempfile
8import shutil
9import os
10import subprocess
11
12class Dnsmasq:
13
14        def __init__(self):
15                #Load template file
16                self.tpl_env = Environment(loader=FileSystemLoader('/usr/share/n4d/templates/dnsmasq'))
17                self.dynamicconfpath = "/var/lib/dnsmasq/"
18                self.dnsfile = self.dynamicconfpath+"hosts/reg" # Format file =====> HOSTIP {HOST_PREFIX}NUMBER_PC_REGISTERED{INTERNAL_DOMAIN}
19                self.pathfile = self.dynamicconfpath+"macs/all-hosts" # Format file ======> dhcp-host=MAC_PC,HOSTIP,{HOST_PREFIX}NUMBER_PC_REGISTERED{INTERNAL_DOMAIN}
20                self.locktocken = "/tmp/lockmacregister"
21                self.leases = "/var/lib/misc/dnsmasq.leases"
22                self.backup_files=["/etc/dnsmasq.conf"]
23                self.backup_dirs=[self.dynamicconfpath,"/etc/dnsmasq.d/"]
24               
25        #def init
26       
27        def startup(self,options):
28                # executed when launching n4d
29                pass
30               
31        #def startup
32
33        def apt(self):
34                # executed after apt operations
35                pass
36               
37        #def apt
38       
39        # service test and backup functions #
40       
41        def test(self):
42
43                pass
44               
45        #def test
46        def makedir(self,dir=None):
47       
48                if not os.path.isdir(dir):
49                        os.makedirs(dir)
50                       
51                return [True]
52               
53        #def get_time
54        def get_time(self):
55
56                return get_backup_name("Dnsmasq")
57
58        #def backup
59        def backup(self,dir="/backup"):
60       
61                try:
62                        self.makedir(dir)
63                        file_path=dir+"/"+self.get_time()     
64                        tar=tarfile.open(file_path,"w:gz")
65                               
66                        for f in self.backup_files:               
67                                if os.path.exists(f):
68                                        tar.add(f)
69
70                        for d in self.backup_dirs:
71                                if os.path.exists(d):
72                                        tar.add(d)
73                        tar.close()
74
75                        return [True,file_path]
76
77                except Exception as e:
78                        return [False,str(e)]
79                       
80               
81        #def restore
82        def restore(self,file_path=None):
83
84                try:                       
85                        if file_path==None:
86                                dir="/backup"
87                                for f in sorted(os.listdir(dir),reverse=True):
88                                        if "Dnsmasq" in f:
89                                                file_path=dir+"/"+f
90                                                break
91
92                        if os.path.exists(file_path):
93                                tmp_dir=tempfile.mkdtemp()
94                                tar=tarfile.open(file_path)
95                                tar.extractall(tmp_dir)
96                                tar.close()
97
98                                for f in self.backup_files:
99                                        tmp_path=tmp_dir+f
100                                        if os.path.exists(tmp_path):
101                                                shutil.copy(tmp_path,f)
102
103                                for d in self.backup_dirs:
104                                        tmp_path=tmp_dir+d
105                                        if os.path.exists(tmp_path):
106                                                #FIX for centralized services in Xenial
107                                                version=objects["ServerBackupManager"].restoring_version
108                                                majorBackupVersion=int(version[0:version.find('.')])
109                                                if majorBackupVersion<=15:
110                                                        #Read tmpdir and exclude centralized services
111                                                        centralizedServices = objects['VariablesManager'].getvalues('SLAVE_BLACKLIST')
112                                                        for cnameFile in listdir(tmp_path):
113                                                                if cnameFile in centralizedServices.values():
114                                                                        restore_as_centralized(cnameFile,d,tmp_path)
115                                                self.makedir(d)
116                                                cmd="cp -r " + tmp_path +"/* "  + d
117                                                os.system(cmd)
118
119                                os.system("service dnsmasq restart")
120
121                                return [True,""]
122
123                        else:
124                                return [False,"Backup file not found"]
125
126                except Exception as e:
127                       
128                        return [False,str(e)]
129                       
130        def restore_as_centralized (self,cnameFile,backup_dir,tmp_path):
131                cnameRealPath=backup_dir + '/' + cnameFile
132                if os.path.isfile(cnameRealPath):
133                        cmd="cp " + cnameRealPath + " tmp_path"
134                        os.system(cmd)
135                else:
136                        os.remove(cnameFile)
137
138        def has_name(self,mac):
139                pass
140        #def has_name
141
142        def set_dns_external(self,dnsexternal):
143                list_variables = {}
144                #Get template
145                template_extradns = self.tpl_env.get_template("extra-dns")
146                #Inicialize DNS_EXTERNAL
147                list_variables['DNS_EXTERNAL'] = objects['VariablesManager'].get_variable('DNS_EXTERNAL')
148                #If variable DNS_EXTERNAL is not defined calculate it with args values
149                status,list_variables['DNS_EXTERNAL'] = objects['VariablesManager'].init_variable('DNS_EXTERNAL',{'DNS':dnsexternal})   
150                #Encode vars to UTF-8
151                string_template = template_extradns.render(list_variables).encode('UTF-8')
152                #Open template file
153                fd, tmpfilepath = tempfile.mkstemp()
154                new_export_file = open(tmpfilepath,'w')
155                new_export_file.write(string_template)
156                new_export_file.close()
157                os.close(fd)
158                #Write template values
159                #shutil.move(tmpfilepath,'/etc/dnsmasq.conf')
160                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/config/extra-dns',True,'root','root','0644',False )
161                return {'status':True,'msg':'Set dns external succesfully'}
162        #def set_dns_external
163       
164        def configure_service(self,domain):
165                list_variables = {}
166                #status,list_variables['SRV_NAME'] = objects['VariablesManager'].init_variable('SRV_NAME',{'NAME':srv_name})
167                status,list_variables['INTERNAL_DOMAIN'] = objects['VariablesManager'].init_variable('INTERNAL_DOMAIN',{'DOMAIN':domain})
168                #self.set_srv_name(srv_name)
169                self.set_internal_domain(domain)
170                self.load_exports()
171                return {'status':True,'msg':'SUCCESS'}                 
172        #def  config_service
173       
174        def add_alias(self,alias):
175                template_cname = self.tpl_env.get_template("cname-server")
176                list_variables = {}
177                #get INTERNAL_DOMAIN
178                list_variables['INTERNAL_DOMAIN'] = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
179                #If INT_DOMAIN is not defined return an error
180                if  list_variables['INTERNAL_DOMAIN'] == None:
181                        return {'status':False,'msg':'Variable INTERNAL_DOMAIN not defined'}
182                #get HOSTNAME
183                list_variables['HOSTNAME'] = objects['VariablesManager'].get_variable('HOSTNAME')
184                #If INT_DOMAIN is not defined return an error
185                if  list_variables['HOSTNAME'] == None:
186                        return {'status':False,'msg':'Variable HOSTNAME not defined'}                   
187               
188                #Add alias to SRV_ALIAS
189                #Obtains actual SRV_ALIAS variable
190                list_variables['SRV_ALIAS'] = objects['VariablesManager'].get_variable('SRV_ALIAS')
191                #Add new alias
192                if list_variables['SRV_ALIAS'] ==None:
193                        list_variables['SRV_ALIAS']=[]
194                list_variables['SRV_ALIAS'].append(alias)
195                #Save new values
196                status,list_variables['SRV_ALIAS'] = objects['VariablesManager'].init_variable('SRV_ALIAS',{'ALIAS':list_variables['SRV_ALIAS']})
197                #return {'status':True,'msg':'Set server name succesfully'}
198               
199                #Encode vars to UTF-8
200                string_template = template_cname.render(list_variables).encode('UTF-8')
201                #Open template file
202                fd, tmpfilepath = tempfile.mkstemp()
203                new_export_file = open(tmpfilepath,'w')
204                new_export_file.write(string_template)
205                new_export_file.close()
206                os.close(fd)
207                #Write template values
208                #shutil.move(tmpfilepath,'/etc/dnsmasq.conf')
209                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/config/cname-server',True,'root','root','0644',False )
210                return {'status':True,'msg':'SRV_ALIAS changed'}
211                self.reboot_dhcpd()
212        #def  add_alias
213       
214        def remove_alias(self,alias):
215                template_cname = self.tpl_env.get_template("cname-server")
216                list_variables = {}
217                #get INTERNAL_DOMAIN
218                list_variables['INTERNAL_DOMAIN'] = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
219                #If INT_DOMAIN is not defined return an error
220                if  list_variables['INTERNAL_DOMAIN'] == None:
221                        return {'status':False,'msg':'Variable INTERNAL_DOMAIN not defined'}
222                #get HOSTNAME
223                list_variables['HOSTNAME'] = objects['VariablesManager'].get_variable('HOSTNAME')
224                #If INT_DOMAIN is not defined return an error
225                if  list_variables['HOSTNAME'] == None:
226                        return {'status':False,'msg':'Variable HOSTNAME not defined'}                   
227               
228                #Add alias to SRV_ALIAS
229                #Obtains actual SRV_ALIAS variable
230                list_variables['SRV_ALIAS'] = objects['VariablesManager'].get_variable('SRV_ALIAS')
231                #Add new alias
232                if list_variables['SRV_ALIAS'] == None:
233                        return {'status':True,'msg':'SRV_ALIAS is empty'}
234                if alias in list_variables['SRV_ALIAS']:
235                        list_variables['SRV_ALIAS'].remove(alias)
236                else:
237                        return {'status':False,'msg': 'alias not found'}
238                #Save new values
239                status,list_variables['SRV_ALIAS'] = objects['VariablesManager'].init_variable('SRV_ALIAS',{'ALIAS':list_variables['SRV_ALIAS']})
240                #return {'status':True,'msg':'Set server name succesfully'}
241               
242                #Encode vars to UTF-8
243                string_template = template_cname.render(list_variables).encode('UTF-8')
244                #Open template file
245                fd, tmpfilepath = tempfile.mkstemp()
246                new_export_file = open(tmpfilepath,'w')
247                new_export_file.write(string_template)
248                new_export_file.close()
249                os.close(fd)
250                #Write template values
251                #shutil.move(tmpfilepath,'/etc/dnsmasq.conf')
252                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/config/cname-server',True,'root','root','0644',False )
253                return {'status':True,'msg':'SRV_ALIAS changed'}
254                self.reboot_dhcpd()
255        #def  config_service
256       
257        '''
258        def set_srv_name(self,name):
259                template_cname = self.tpl_env.get_template("cname-server")
260                list_variables = {}
261                #get INTERNAL_DOMAIN
262                list_variables['INTERNAL_DOMAIN'] = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
263                #If INT_DOMAIN is not defined return an error
264                if  list_variables['INTERNAL_DOMAIN'] == None:
265                        return {'status':False,'msg':'Variable INTERNAL_DOMAIN not defined'}
266
267                #Inicialize SRV_NAME
268                status,list_variables['SRV_NAME'] = objects['VariablesManager'].init_variable('SRV_NAME',{'NAME':name})
269                #return {'status':True,'msg':'Set server name succesfully'}
270               
271                #Encode vars to UTF-8
272                string_template = template_cname.render(list_variables).encode('UTF-8')
273                #Open template file
274                fd, tmpfilepath = tempfile.mkstemp()
275                new_export_file = open(tmpfilepath,'w')
276                new_export_file.write(string_template)
277                new_export_file.close()
278                os.close(fd)
279                #Write template values
280                #shutil.move(tmpfilepath,'/etc/dnsmasq.conf')
281                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/config/cname-server',True,'root','root','0644',False )
282                return {'status':True,'msg':'SRV_NAME changed'}
283        '''
284       
285        def set_internal_domain(self,domain):
286                list_variables = {}
287                #Get HOSTNAME
288                list_variables['HOSTNAME'] = objects['VariablesManager'].get_variable('HOSTNAME')
289                #If variable INTERNAL_DOMAIN is not defined calculate it with args values
290                if  list_variables['HOSTNAME'] == None:
291                        return {'status':False,'msg':'Variable HOSTNAME is not defined'}
292                #Set INTERNAL_DOMAIN with args values
293                status,list_variables['INTERNAL_DOMAIN'] = objects['VariablesManager'].init_variable('INTERNAL_DOMAIN',{'DOMAIN':domain})
294                return {'status':True,'msg':'Set internal domain succesfully'}
295               
296        def load_exports(self):
297                #Get template
298                template = self.tpl_env.get_template("dnsmasq.conf")
299                template_cname = self.tpl_env.get_template("cname-server")
300                template_server = self.tpl_env.get_template("server")
301                template_dhclientconf = self.tpl_env.get_template("dhclient.conf")
302               
303                list_variables = {}
304
305                ###########################
306                #Getting VARS
307                ###########################
308
309                #Obtains INTERNAL_INTERFACE
310                list_variables['INTERNAL_INTERFACE'] = objects['VariablesManager'].get_variable('INTERNAL_INTERFACE')
311                #If INTERNAL_INTERFACE is not defined returns an error
312                if  list_variables['INTERNAL_INTERFACE'] == None:
313                        return {'status':False,'msg':'Variable INTERNAL_INTERFACE not defined'}
314
315                #Obtains INTERNAL_NETWORK
316                list_variables['INTERNAL_NETWORK'] = objects['VariablesManager'].get_variable('INTERNAL_NETWORK')
317                #If INTERNAL_NETWORK is not defined returns an error
318                if  list_variables['INTERNAL_NETWORK'] == None:
319                        return {'status':False,'msg':'Variable INTERNAL_NETWORK not defined'}
320
321                #Obtains INTERNAL_MASK
322                list_variables['INTERNAL_MASK'] = objects['VariablesManager'].get_variable('INTERNAL_MASK')
323                #If INTERNAL_NETWORK is not defined returns an error
324                if  list_variables['INTERNAL_MASK'] == None:
325                        return {'status':False,'msg':'Variable INTERNAL_MASK not defined'}
326       
327                #Inicialize INTERNAL_DOMAIN
328                list_variables['INTERNAL_DOMAIN'] = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
329                #If INT_DOMAIN is not defined calculate it with args values
330                if  list_variables['INTERNAL_DOMAIN'] == None:
331                        return {'status':False,'msg':'Variable INTERNAL_DOMAIN not defined'}
332                       
333                #Obtains SRV_IP
334                list_variables['SRV_IP'] = objects['VariablesManager'].get_variable('SRV_IP')
335                #If variable SRV_IP is not defined returns an error
336                if  list_variables['SRV_IP'] == None:
337                        return {'status':False,'msg':'Variable SRV_IP not defined'}
338                '''     
339                #Obtains SRV_NAME
340                list_variables['SRV_NAME'] = objects['VariablesManager'].get_variable('SRV_NAME')
341                #If variable SRV_IP is not defined returns an error
342                if  list_variables['SRV_NAME'] == None:
343                        return {'status':False,'msg':'Variable SRV_NAME not defined'}
344                '''
345                #Obtains HOSTNAME
346                list_variables['HOSTNAME'] = objects['VariablesManager'].get_variable('HOSTNAME')
347                #If variable SRV_IP is not defined returns an error
348                if  list_variables['HOSTNAME'] == None:
349                        return {'status':False,'msg':'Variable HOSTNAME not defined'}           
350
351                ############################
352                #Setting VARS
353                ############################
354               
355                #Inicialize DHCP_ENABLE
356                #list_variables['DHCP_ENABLE'] = objects['VariablesManager'].get_variable('DHCP_ENABLE')
357                #If variable DHCP_ENABLE is not defined calculate it with args values
358                #if  list_variables['DHCP_ENABLE'] == None:
359                status,list_variables['DHCP_ENABLE'] = objects['VariablesManager'].init_variable('DHCP_ENABLE',{'ENABLE':'True'})
360               
361                #Inicialize DHCP_LEASE_TIME
362                #list_variables['DHCP_LEASE_TIME'] = objects['VariablesManager'].get_variable('DHCP_LEASE_TIME')
363                #If variable DHCP_LEASE_TIME is not defined calculate it with args values
364                #if  list_variables['DHCP_LEASE_TIME'] == None:
365                status,list_variables['DHCP_LEASE_TIME'] = objects['VariablesManager'].init_variable('DHCP_LEASE_TIME',{'LEASE_TIME':12})
366
367                #Inicialize DHCP_DENY_UNKNOWN_CLIENTS
368                #list_variables['DHCP_DENY_UNKNOWN_CLIENTS'] = objects['VariablesManager'].get_variable('DHCP_DENY_UNKNOWN_CLIENTS')
369                #If variable DHCP_DENY_UNKNOWN_CLIENTS is not defined calculate it with args values
370                #if  list_variables['DHCP_DENY_UNKNOWN_CLIENTS'] == None:
371                status,list_variables['DHCP_DENY_UNKNOWN_CLIENTS'] = objects['VariablesManager'].init_variable('DHCP_DENY_UNKNOWN_CLIENTS',{'DENY_UNKNOWN':'no'})
372
373                #Inicialize DHCP_HOST_MAX
374                #list_variables['DHCP_HOST_MAX'] = objects['VariablesManager'].get_variable('DHCP_HOST_MAX')
375                #If variable DHCP_HOST_MAX is not defined calculate it with args values
376                #if  list_variables['DHCP_HOST_MAX'] == None:
377                status,list_variables['DHCP_HOST_MAX'] = objects['VariablesManager'].init_variable('DHCP_HOST_MAX',{'HOST_MAX':80})
378
379                #Inicialize DHCP_FIRST_IP
380                #list_variables['DHCP_FIRST_IP'] = objects['VariablesManager'].get_variable('DHCP_FIRST_IP')
381                #If variable DHCP_FIRST_IP is not defined calculate it with args values
382                #if  list_variables['DHCP_FIRST_IP'] == None:
383                status,list_variables['DHCP_FIRST_IP'] = objects['VariablesManager'].init_variable('DHCP_FIRST_IP',{'NETWORK':list_variables['INTERNAL_NETWORK'],'MASK':list_variables['INTERNAL_MASK']})
384
385                #Inicialize DHCP_LAST_IP
386                #list_variables['DHCP_LAST_IP'] = objects['VariablesManager'].get_variable('DHCP_LAST_IP')
387                #If variable DHCP_LAST_IP is not defined calculate it with args values
388                #if  list_variables['DHCP_LAST_IP'] == None:
389                status,list_variables['DHCP_LAST_IP'] = objects['VariablesManager'].init_variable('DHCP_LAST_IP',{'NETWORK':list_variables['INTERNAL_NETWORK'],'MASK':list_variables['INTERNAL_MASK']})
390                       
391                #Inicialize DNS_HOSTNAME_PREFIX
392                #list_variables['DNS_HOSTNAME_PREFIX'] = objects['VariablesManager'].get_variable('DNS_HOSTNAME_PREFIX')
393                #If variable DNS_HOSTNAME_PREFIX is not defined calculate it with args values
394                #if  list_variables['DNS_HOSTNAME_PREFIX'] == None:
395                status,list_variables['DNS_HOSTNAME_PREFIX'] = objects['VariablesManager'].init_variable('DNS_HOSTNAME_PREFIX',{'PREFIX':'llx-'})
396
397                #Inicialize DNS_UNREG_HOSTNAME_PREFIX
398                #list_variables['DNS_UNREG_HOSTNAME_PREFIX'] = objects['VariablesManager'].get_variable('DNS_UNREG_HOSTNAME_PREFIX')
399                #If variable DNS_UNREG_HOSTNAME_PREFIX is not defined calculate it with args values
400                #if  list_variables['DNS_UNREG_HOSTNAME_PREFIX'] == None:
401                status,list_variables['DNS_UNREG_HOSTNAME_PREFIX'] = objects['VariablesManager'].init_variable('DNS_UNREG_HOSTNAME_PREFIX',{'PREFIX':'host-'})
402       
403                #Inicialize SRV_ALIAS
404                #list_variables['SRV_ALIAS'] = objects['VariablesManager'].get_variable('SRV_ALIAS')
405                #If variable SRV_ALIAS is not defined calculate it with args values
406                #if  list_variables['SRV_ALIAS'] == None:
407                status,list_variables['SRV_ALIAS'] = objects['VariablesManager'].init_variable('SRV_ALIAS')
408       
409       
410                #Encode vars to UTF-8
411                string_template = template.render(list_variables).encode('UTF-8')
412                #Open template file
413                fd, tmpfilepath = tempfile.mkstemp()
414                new_export_file = open(tmpfilepath,'w')
415                new_export_file.write(string_template)
416                new_export_file.close()
417                os.close(fd)
418                #Write template values
419                #shutil.move(tmpfilepath,'/etc/dnsmasq.conf')
420                n4d_mv(tmpfilepath,'/etc/dnsmasq.conf',True,'root','root','0644',False )
421               
422                #Encode vars to UTF-8
423                string_template = template_cname.render(list_variables).encode('UTF-8')
424                #Open template file
425                fd, tmpfilepath = tempfile.mkstemp()
426                new_export_file = open(tmpfilepath,'w')
427                new_export_file.write(string_template)
428                new_export_file.close()
429                os.close(fd)
430                #Write template values
431                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/config/cname-server',True,'root','root','0644',False )
432               
433                #Encode vars to UTF-8
434                string_template = template_server.render(list_variables).encode('UTF-8')
435                #Open template file
436                fd, tmpfilepath = tempfile.mkstemp()
437                new_export_file = open(tmpfilepath,'w')
438                new_export_file.write(string_template)
439                new_export_file.close()
440                os.close(fd)
441                #Write template values
442                n4d_mv(tmpfilepath,'/var/lib/dnsmasq/hosts/server',True,'root','root','0644',False )
443               
444                #Encode vars to UTF-8
445                string_template = template_dhclientconf.render(list_variables).encode('UTF-8')
446                #Open template file
447                fd, tmpfilepath = tempfile.mkstemp()
448                new_export_file = open(tmpfilepath,'w')
449                new_export_file.write(string_template)
450                new_export_file.close()
451                os.close(fd)
452                #Write template values
453                n4d_mv(tmpfilepath,'/etc/dhcp/dhclient.conf',True,'root','root','0644',False )
454               
455                return {'status':True,'msg':'Service configured'}
456        #def load_exports
457       
458        def set_dns_master_services(self):
459
460                ip = '10.3.0.254'
461                listservices = []
462                listnames = objects['VariablesManager'].get_variable('SLAVE_BLACKLIST')#{'':['']}
463                allok = True
464                msg=[]
465
466                for x in listnames.keys():
467                        listservices.extend(listnames[x])
468
469                for service in listservices:
470                        result = self.set_external_dns_entry(service,ip)
471                        if not result['status']:
472                                allok = False
473                                msg.append(result['msg'])
474                return {'status':allok,'msg':msg}
475
476        #def set_dns_master_services
477
478        def set_internal_dns_entry(self,name):
479                try:
480                        internal = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
481                        hostname = objects['VariablesManager'].get_variable('HOSTNAME')
482                        f = open(self.dynamicconfpath+'config/'+name,'w')
483                        f.write("cname="+name+"."+ internal +","+ hostname + "."+internal)
484                        f.close()
485                        if os.path.exists(self.dynamicconfpath+'hosts/'+name):
486                                os.remove(self.dynamicconfpath+'hosts/'+name)
487                        return {'status':True,'msg':''}
488                except Exception as e:
489                        return {'status':False,'msg':str(e)}
490
491        def set_external_dns_entry(self,name,ip):
492                try:
493                        f = open(self.dynamicconfpath+'hosts/'+name,'w')
494                        f.write(ip + ' '+ name)
495                        f.close()
496                        if os.path.exists(self.dynamicconfpath+'config/'+name):
497                                os.remove(self.dynamicconfpath+'config/'+name)
498                        return {'status':True,'msg':''}
499                except Exception as e:
500                        return {'status':False,'msg':str(e)}   
501
502        #def set_dns_entry
503
504        def reboot_dhcpd(self):
505                #Restart dhcpd service
506                subprocess.Popen(['service','dnsmasq','restart'],stdout=subprocess.PIPE).communicate()
507                return {'status':True,'msg':'DNSMASQ rebooted'}
508        #def reboot_dhcpd
509
510
511        def get_available_id_list(self):
512                new_hostname_prefix = objects['VariablesManager'].get_variable('DNS_HOSTNAME_PREFIX')
513                new_hostname_sufix = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
514                lavailable = range(1,self._subtraction_ip(objects['VariablesManager'].get_variable('DHCP_FIRST_IP'),objects['VariablesManager'].get_variable('DHCP_LAST_IP')))
515                default = self._get_first_id_available(new_hostname_prefix,new_hostname_sufix)
516                if int(default) > int(lavailable[-1]):
517                        default = lavailable[-1]
518                return {'status':True,'result':lavailable,'default':default}
519        #def get_available_id_list
520       
521        def remove_register(self,mac):
522                if not os.path.exists(self.locktocken):
523                        open(self.locktocken,'a')
524                else:
525                        return {'status':False,'msg':'Server is locked now' }
526                registerfile = open(self.pathfile,'r')
527                content = registerfile.readlines()
528                registerfile.close()
529                found = False
530                found_str = ""
531                new_content = []
532                #dhcp-host=00:0F:FE:C3:D9:EC,10.0.2.1,llx-pc01
533                for line in content:
534                        try:
535                                auxline = line.strip('\n')
536                                auxline = auxline.split('=')[1]
537                                lmac,lip,lhostname = auxline.split(',')
538                        except:
539                                continue
540                        if lmac == mac :
541                                found = True
542                                found_str = lip + " " + lhostname
543                        else:
544                                new_content.append(line)
545                if not found :
546                        os.remove(self.locktocken)
547                        return {'status':False,'result':'MAC ' + mac + ' is not registred' }
548                else:
549                        #mac founded
550                        registerfile = open(self.pathfile,'w')
551                        for line in new_content:
552                                registerfile.write(line)
553                        registerfile.close()
554                       
555                        new_content = []
556                        dnsfile = open(self.dnsfile,'r')
557                        content = dnsfile.readlines()
558                        dnsfile.close()
559                        for line in content:
560                                line_striped = line.strip()
561                                if (line_striped != found_str):
562                                        new_content.append(line)
563                       
564                        dnsfile = open(self.dnsfile,'w')
565                        for line in new_content:
566                                dnsfile.write(line)
567                        dnsfile.close()
568                       
569                        os.remove(self.locktocken)
570                        return {'status':True,'result':'MAC '+mac+' has been removed' }
571        #def register_machine
572       
573        def register_machine(self,id,mac,isteacher):
574                #Check if this process is running
575                if not os.path.exists(self.locktocken):
576                        open(self.locktocken,'a')
577                else:
578                        return {'status':False,'result':'Server is locked now' }
579
580                new_hostname_prefix = objects['VariablesManager'].get_variable('DNS_HOSTNAME_PREFIX')
581                new_hostname_sufix = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
582                if int(id) < 10 :
583                        new_hostname = new_hostname_prefix + "0" + id + new_hostname_sufix
584                else:
585                        new_hostname = new_hostname_prefix + id + new_hostname_sufix
586                ip_base = objects['VariablesManager'].get_variable('INTERNAL_NETWORK')
587                new_ip = self._increment_ip(ip_base,id)
588                if new_ip == None:
589                        os.remove(self.locktocken)
590                        return {'status':False,'result':'Not found ip for ' + new_hostname}
591                # dhcp-host=MAC_PC,HOSTIP,{HOST_PREFIX}NUMBER_PC_REGISTERED{INTERNAL_DOMAIN}
592                new_content = []
593                registerfile = open(self.pathfile,'r')
594                content = registerfile.readlines()             
595                for line in content:
596                        try:
597                                auxline = line.split('=')[1]
598                                lmac,lip,lhostname = auxline.split(',')
599                                lhostname = lhostname.strip()
600                        except:
601                                continue
602                        if new_hostname != lhostname and lmac != mac:
603                                new_content.append(line)
604                registerfile.close()
605               
606                new_content.append("dhcp-host=" + mac + "," + new_ip + ","+ new_hostname +"\n")
607                registerfile = open(self.pathfile,'w')
608                for line in new_content:
609                        registerfile.write(line)
610                registerfile.close()
611               
612                # HOSTIP {HOST_PREFIX}NUMBER_PC_REGISTERED{INTERNAL_DOMAIN}
613                new_content = []
614                dnsfile = open(self.dnsfile,'r')
615                content = dnsfile.readlines()
616                for line in content:
617                        try:
618                                lip,lhostname = line.split(' ')
619                                lhostname = lhostname.strip()
620                        except:
621                                continue
622                        if new_hostname != lhostname and lip != new_ip:
623                                new_content.append(line)
624                dnsfile.close()
625               
626                new_content.append(new_ip + " " + new_hostname + "\n")
627                dnsfile = open(self.dnsfile,'w')
628                for line in new_content:
629                        dnsfile.write(line)
630                dnsfile.close()
631               
632                os.remove(self.locktocken)
633                return {'status':True,'result':'MAC '+ mac + ' has been registered with id ' + id }
634        #def register_machine
635       
636        '''
637        Internal method
638        '''
639       
640        def _subtraction_ip(self,a,b):
641                list_a = a.split('.')
642                list_a.reverse()
643                list_b = b.split('.')
644                list_b.reverse()
645                total = 0
646                for i in range(len(list_a)):
647                        if i > 0 :
648                                total += (int(list_b[i]) - int(list_a[i])) * (256 ** i)
649                        else:
650                                total += int(list_b[i]) - int(list_a[i]) + 1
651                return total
652        #def _subtraction_ip
653       
654        def _get_ip_by_mac(self, mac):
655                f = open(self.leases,'r')
656                all_lines = f.readlines()
657                ip = ""
658                for line in all_lines:
659                        try:
660                                list_params = line.split(' ')
661                                if (list_params[1] == mac ):
662                                        ip = list_params[2]
663                                        break
664                        except Exception as e:
665                                pass
666                f.close()
667                if (ip == ""):
668                        return None
669                else:
670                        return ip
671        #def _get_ip_by_mac
672       
673        def _get_first_id_available(self,head,foot):
674                f = open(self.dnsfile,'r')
675                lines = f.readlines()
676                final = []
677                for x in lines:
678                        s = re.search(".*"+head+"(\d*)"+foot+".*",x)
679                        if s != None:
680                                final.append(s.group(1))
681                if (len(final) == 0) or (int(final[0]) > 1):
682                        return 0
683                z = 0
684                found = False
685                for x in final:
686                        z += 1
687                        if z != int(x):
688                                found = True
689                                break
690                if not found:
691                        z += 1
692                return z
693        #def _get_first_id_available
694       
695        def _increment_ip(self,base,num):
696                try:
697                        ip = base.split('.')
698                        last_octect = ip[-1]
699                        x = int(last_octect) + int(num)
700                        t_octect = x / 256
701                        l_octect = x % 256
702                        calculed_ip =  ip[0]+"."+ip[1]+"."+str(int(ip[2])+t_octect)+ "." + str(l_octect)
703                        return calculed_ip
704                except:
705                        return None     
706
707       
708
709
710#class Dnsmasq
Note: See TracBrowser for help on using the repository browser.