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

Last change on this file since 1503 was 1503, checked in by kbut, 5 years ago

wip

File size: 23.4 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_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_dns_entry(self,name,ip):
464                try:
465                        f = open(self.dynamicconfpath+'hosts/'+name,'w')
466                        f.write(ip + ' '+ name)
467                        f.close()
468                        return {'status':True,'msg':"all ok"}
469                except Exception as e:
470                        return {'status':False,'msg':str(e)}
471
472        #def set_dns_entry
473
474        def reboot_dhcpd(self):
475                #Restart dhcpd service
476                subprocess.Popen(['service','dnsmasq','restart'],stdout=subprocess.PIPE).communicate()
477                return {'status':True,'msg':'DNSMASQ rebooted'}
478        #def reboot_dhcpd
479
480
481        def get_available_id_list(self):
482                new_hostname_prefix = objects['VariablesManager'].get_variable('DNS_HOSTNAME_PREFIX')
483                new_hostname_sufix = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
484                lavailable = range(1,self._subtraction_ip(objects['VariablesManager'].get_variable('DHCP_FIRST_IP'),objects['VariablesManager'].get_variable('DHCP_LAST_IP')))
485                default = self._get_first_id_available(new_hostname_prefix,new_hostname_sufix)
486                if int(default) > int(lavailable[-1]):
487                        default = lavailable[-1]
488                return {'status':True,'result':lavailable,'default':default}
489        #def get_available_id_list
490       
491        def remove_register(self,mac):
492                if not os.path.exists(self.locktocken):
493                        open(self.locktocken,'a')
494                else:
495                        return {'status':False,'msg':'Server is locked now' }
496                registerfile = open(self.pathfile,'r')
497                content = registerfile.readlines()
498                registerfile.close()
499                found = False
500                found_str = ""
501                new_content = []
502                #dhcp-host=00:0F:FE:C3:D9:EC,10.0.2.1,llx-pc01
503                for line in content:
504                        try:
505                                auxline = line.strip('\n')
506                                auxline = auxline.split('=')[1]
507                                lmac,lip,lhostname = auxline.split(',')
508                        except:
509                                continue
510                        if lmac == mac :
511                                found = True
512                                found_str = lip + " " + lhostname
513                        else:
514                                new_content.append(line)
515                if not found :
516                        os.remove(self.locktocken)
517                        return {'status':False,'result':'MAC ' + mac + ' is not registred' }
518                else:
519                        #mac founded
520                        registerfile = open(self.pathfile,'w')
521                        for line in new_content:
522                                registerfile.write(line)
523                        registerfile.close()
524                       
525                        new_content = []
526                        dnsfile = open(self.dnsfile,'r')
527                        content = dnsfile.readlines()
528                        dnsfile.close()
529                        for line in content:
530                                line_striped = line.strip()
531                                if (line_striped != found_str):
532                                        new_content.append(line)
533                       
534                        dnsfile = open(self.dnsfile,'w')
535                        for line in new_content:
536                                dnsfile.write(line)
537                        dnsfile.close()
538                       
539                        os.remove(self.locktocken)
540                        return {'status':True,'result':'MAC '+mac+' has been removed' }
541        #def register_machine
542       
543        def register_machine(self,id,mac,isteacher):
544                #Check if this process is running
545                if not os.path.exists(self.locktocken):
546                        open(self.locktocken,'a')
547                else:
548                        return {'status':False,'result':'Server is locked now' }
549
550                new_hostname_prefix = objects['VariablesManager'].get_variable('DNS_HOSTNAME_PREFIX')
551                new_hostname_sufix = objects['VariablesManager'].get_variable('INTERNAL_DOMAIN')
552                if int(id) < 10 :
553                        new_hostname = new_hostname_prefix + "0" + id + new_hostname_sufix
554                else:
555                        new_hostname = new_hostname_prefix + id + new_hostname_sufix
556                ip_base = objects['VariablesManager'].get_variable('INTERNAL_NETWORK')
557                new_ip = self._increment_ip(ip_base,id)
558                if new_ip == None:
559                        os.remove(self.locktocken)
560                        return {'status':False,'result':'Not found ip for ' + new_hostname}
561                # dhcp-host=MAC_PC,HOSTIP,{HOST_PREFIX}NUMBER_PC_REGISTERED{INTERNAL_DOMAIN}
562                new_content = []
563                registerfile = open(self.pathfile,'r')
564                content = registerfile.readlines()             
565                for line in content:
566                        try:
567                                auxline = line.split('=')[1]
568                                lmac,lip,lhostname = auxline.split(',')
569                                lhostname = lhostname.strip()
570                        except:
571                                continue
572                        if new_hostname != lhostname and lmac != mac:
573                                new_content.append(line)
574                registerfile.close()
575               
576                new_content.append("dhcp-host=" + mac + "," + new_ip + ","+ new_hostname +"\n")
577                registerfile = open(self.pathfile,'w')
578                for line in new_content:
579                        registerfile.write(line)
580                registerfile.close()
581               
582                # HOSTIP {HOST_PREFIX}NUMBER_PC_REGISTERED{INTERNAL_DOMAIN}
583                new_content = []
584                dnsfile = open(self.dnsfile,'r')
585                content = dnsfile.readlines()
586                for line in content:
587                        try:
588                                lip,lhostname = line.split(' ')
589                                lhostname = lhostname.strip()
590                        except:
591                                continue
592                        if new_hostname != lhostname and lip != new_ip:
593                                new_content.append(line)
594                dnsfile.close()
595               
596                new_content.append(new_ip + " " + new_hostname + "\n")
597                dnsfile = open(self.dnsfile,'w')
598                for line in new_content:
599                        dnsfile.write(line)
600                dnsfile.close()
601               
602                os.remove(self.locktocken)
603                return {'status':True,'result':'MAC '+ mac + ' has been registered with id ' + id }
604        #def register_machine
605       
606        '''
607        Internal method
608        '''
609       
610        def _subtraction_ip(self,a,b):
611                list_a = a.split('.')
612                list_a.reverse()
613                list_b = b.split('.')
614                list_b.reverse()
615                total = 0
616                for i in range(len(list_a)):
617                        if i > 0 :
618                                total += (int(list_b[i]) - int(list_a[i])) * (256 ** i)
619                        else:
620                                total += int(list_b[i]) - int(list_a[i]) + 1
621                return total
622        #def _subtraction_ip
623       
624        def _get_ip_by_mac(self, mac):
625                f = open(self.leases,'r')
626                all_lines = f.readlines()
627                ip = ""
628                for line in all_lines:
629                        try:
630                                list_params = line.split(' ')
631                                if (list_params[1] == mac ):
632                                        ip = list_params[2]
633                                        break
634                        except Exception as e:
635                                pass
636                f.close()
637                if (ip == ""):
638                        return None
639                else:
640                        return ip
641        #def _get_ip_by_mac
642       
643        def _get_first_id_available(self,head,foot):
644                f = open(self.dnsfile,'r')
645                lines = f.readlines()
646                final = []
647                for x in lines:
648                        s = re.search(".*"+head+"(\d*)"+foot+".*",x)
649                        if s != None:
650                                final.append(s.group(1))
651                if (len(final) == 0) or (int(final[0]) > 1):
652                        return 0
653                z = 0
654                found = False
655                for x in final:
656                        z += 1
657                        if z != int(x):
658                                found = True
659                                break
660                if not found:
661                        z += 1
662                return z
663        #def _get_first_id_available
664       
665        def _increment_ip(self,base,num):
666                try:
667                        ip = base.split('.')
668                        last_octect = ip[-1]
669                        x = int(last_octect) + int(num)
670                        t_octect = x / 256
671                        l_octect = x % 256
672                        calculed_ip =  ip[0]+"."+ip[1]+"."+str(int(ip[2])+t_octect)+ "." + str(l_octect)
673                        return calculed_ip
674                except:
675                        return None     
676
677       
678
679
680#class Dnsmasq
Note: See TracBrowser for help on using the repository browser.