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

Last change on this file since 1557 was 1557, checked in by kbut, 4 years ago

add function to exteral and internal name domains

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