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

Last change on this file since 5231 was 5231, checked in by Juanma, 22 months ago

Add alias for admin-center when restoring a backup from <=15

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