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

Last change on this file since 2018 was 2018, checked in by Juanma, 3 years ago

Fix bug on backup from Trusty

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