Changeset 6016


Ignore:
Timestamp:
Oct 11, 2017, 6:29:27 PM (2 years ago)
Author:
kbut
Message:

update with upstream ;)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • python-llxnet/trunk/fuentes/src/lliurex/interfacesparser.py

    r157 r6016  
     1import os.path
     2
     3
    14class StanzaBasic(object):
    2         def __init__(self,list_interfaces):
     5        def __init__(self, list_interfaces):
    36                '''
    47                        list_interfaces is list
     
    69                self.type = ''
    710                self.interfaces = []
    8                 if(type(list_interfaces) == type([])):
     11                if isinstance(list_interfaces, list):
    912                        for i in list_interfaces:
    1013                                self.interfaces.append(i)
     
    1316        #def __init__
    1417       
    15         def append_interface(self,interface,order=-1): 
     18        def append_interface(self, interface, order=-1):       
    1619                if(order < 0):
    1720                        self.interfaces.append(interface)
    1821                else:
    19                         aux_interface_list = self.interfaces[:order] + [interface]+ self.interfaces[order:]
    20                         self.interfaces = aux_interface_list
    21                
     22                        self.interfaces.insert(order, interface)
    2223                return interface
    2324        #def append_interface
    2425       
    25         def remove_interface(self,interface):
    26                 if interface in self.interface:
    27                         i = self.interface(interface)
    28                         return self.options.pop(i)
    29                 return None
     26        def remove_interface(self, interface):
     27                try:
     28                        self.interfaces.remove(interface)
     29                        return interface
     30                except:
     31                        return None
    3032        #def append_interface
    3133
     
    3436        #def get_interfaces
    3537
     38
    3639class StanzaAuto(StanzaBasic):
    37         def __init__(self,list_interfaces):
     40        def __init__(self, list_interfaces):
    3841                '''
    3942                        list_interfaces is list
     
    4750        #def print_stanza
    4851
     52
    4953class StanzaMapping(StanzaBasic):
    50         def __init__(self,list_interfaces):
     54        def __init__(self, list_interfaces):
    5155                '''
    5256                        list_interfaces is list
     
    5458                super(StanzaMapping,self).__init__(list_interfaces)
    5559                self.type = 'mapping'
    56                 self.script = {'path':'','order':0}
     60                self.script = { 'path':'', 'order':0 }
    5761                self.options = []
    5862        #def __init__
     
    7377        #def get_all_options
    7478       
    75         def set_option(self,option_string):
    76                 if (type(option_string) != type('')):
     79        def set_option(self, option_string):
     80                if not isinstance(option_string, str):
    7781                        raise Exception('Option must be string')
    7882                strip_option = option_string.strip()
     
    8589        #def set_option
    8690
    87         def remove_option(self,option_string):
     91        def remove_option(self, option_string):
    8892                if option_string in self.options:
    8993                        i = self.options.index(option_string)
    90                         if ( self.script['order'] > i ):
    91                                 self.script['order'] -= 1;
     94                        if self.script['order'] > i:
     95                                self.script['order'] -= 1
    9296                        return self.options.pop(i)
    9397                else:
     
    102106        #def print_stanza
    103107
     108
    104109class StanzaSource:
    105         def __init__(self,path):
     110        def __init__(self, path):
    106111                self.type = 'source'
    107112                self.path = ''
     
    124129        #def print_stanza
    125130
     131
    126132class StanzaAllow(StanzaBasic):
    127         def __init__(self,allow,list_interfaces):
     133        def __init__(self,allow, list_interfaces):
    128134                '''
    129135                        list_interfaces is list
     
    140146class StanzaIface(StanzaBasic):
    141147       
    142         def __init__(self,list_interfaces,options):
     148        def __init__(self, list_interfaces, options):
    143149                '''
    144150                        list_interfaces is list
     
    154160                self.family = ''
    155161                self.method = ''
     162
    156163                aux = options.split(" ")
    157164                if (len(aux) == 2 ):
     
    167174                                                self.family = x
    168175                                                self.method = aux
     176                                                break
    169177                                        else:
    170178                                                raise Exception("Method not supported")
     
    172180
    173181        def change_to_dhcp(self):
    174                 if (self.family == 'can' or self.family == 'ipx'):
     182                if 'dhcp' not in self.__list_family[self.family] :
    175183                        raise Exception("Family no support dhcp method")
    176184                self.method = 'dhcp'
     
    186194        #def change_to_dhcp
    187195
    188         def change_to_static(self,address,netmask,aux_options=[]):
    189                 if (self.family == 'can' or self.family == 'ipx'):
     196        def change_to_static(self, address, netmask, aux_options=[]):
     197                if 'static' not in self.__list_family[self.family]:
    190198                        raise Exception("Now not support change to static method for family " + self.family)
    191199                self.method = 'static'
    192                 not_removed_options = []
    193                 not_removed_options.append('address ' + address)
    194                 not_removed_options.append('netmask ' + netmask)
    195                 not_removed_options = not_removed_options + aux_options
     200                not_removed_options = ['address ' + address, 'netmask ' + netmask ] + aux_options
    196201                list_new_options = []
    197202                for x in not_removed_options:
     
    207212        #def change_to_static
    208213       
    209         def set_option(self,option_string,unique=False):
    210                 if (type(option_string) != type('')):
     214        def set_option(self, option_string, unique=False):
     215                if not isinstance(option_string, str):
    211216                        raise Exception('Option must be string')
    212217                strip_option = option_string.strip()
     
    218223        #def set_option
    219224       
    220         def remove_option(self,option_string,startswith=False):
     225        def remove_option(self, option_string, startswith=False):
    221226                if (startswith):
    222227                        return_list = []
    223                         for i in range(0,len(self.options)):
     228                        for i in range(len(self.options) -1, -1, -1):
    224229                                if self.options[i].startswith(option_string):
    225230                                        return_list.append(self.options.pop(i))
     
    239244        #def print_stanza
    240245
     246        def check_option(self, option, contain=False):
     247                if option in self.options:
     248                        return True
     249                if contain:
     250                        for aux_option in self.options:
     251                                if aux_option.startswith(option):
     252                                        return True
     253                return False
     254
     255
     256        def change_ip(self, ip):
     257                if self.method != 'static' :
     258                        raise Exception("This interface isn't on static configuration")
     259                for x in range(0,len(self.options)):
     260                        if self.options[x].startswith('address'):
     261                                self.options[x] = 'address ' + ip
     262                                return True
     263                self.options.append('address ' + ip)
     264                return True
     265        #def change_ip
     266
     267        def change_netmask(self,netmask):
     268                if self.method != 'static' :
     269                        raise Exception("This interface isn't on static configuration")
     270                for x in range(0,len(self.options)):
     271                        if self.options[x].startswith('netmask'):
     272                                self.options[x] = 'netmask ' + netmask
     273                                return True
     274                self.options.append('netmask ' + netmask)
     275                return True
     276        #def change_netmask
     277
     278
     279
    241280class StanzaComment:
    242281        def __init__(self,comment):
     
    247286                return self.comment
    248287
    249 import os.path
    250 import exceptions
    251 
    252288class InterfacesParser:
    253         def __init__(self,logfile='/tmp/InterfacesParser'):
     289        def __init__(self, logfile='/tmp/InterfacesParser'):
    254290                self.content = []
    255291                self.stanza_supported = ['iface','allow','auto','source','mapping']
     
    257293                self.log_path = logfile
    258294                self.path = ""
     295
     296        def write_file(self, path):
     297                output = open(path, 'w')
     298                output.write(self.print_file)
     299                output.close()
     300
     301        def print_file(self):
     302                result = ""
     303                for x in self.content:
     304                        result += x.print_stanza()+"\n"
     305                return result
     306
     307        def __insert_interface_reference(self, interface, stanza):
     308                if not interface in self.interface_mapping.keys():
     309                        self.interface_mapping[interface] = []
     310                self.interface_mapping[interface].append(stanza)
    259311               
    260         def write_file(self,path):
    261                 output = open(path,'w')
    262                 for x in self.content:
    263                         output.write(x.print_stanza()+"\n")
    264                         #output.write(x+"\n")
    265         def __insert_interface_reference(self,interface,position):
    266                 if(not self.interface_mapping.has_key(interface)):
    267                         self.interface_mapping[interface] = []
    268                 self.interface_mapping[interface].append(position)
    269        
    270         def load(self,path,log_write_method='a'):
     312        def load(self, path, log_write_method='a'):
    271313                if( not os.path.exists(path)):
    272314                        raise Exception("Path " + str(path) + " not exists")
     
    294336
    295337                        if (striped_line.endswith('\\')):
    296                                 if (not striped_line.startswith('#')):
     338                                if (not striped_line.startswith('#') or striped_line.startswith('//')):
    297339                                        multiline = True
    298340                                        aux_lines[-1] = aux_lines[-1][:-1]
     
    304346                aux_stanza = None
    305347                for x in aux_lines:
    306                         if (x.startswith('#')):
     348                        if (x.startswith('#') or x.startswith('//')):
    307349                                if (aux_stanza != None):
    308350                                        self.content.append(aux_stanza)
     
    351393                                                        log_fh.write("File contain error with '" + " ".join(stanza_splited) + "' .This line is in invalid stanza." )
    352394                                                        continue
    353                                                
     395               
    354396                if (aux_stanza != None):
    355397                        self.content.append(aux_stanza)
    356398                       
    357                 for i in range(0,len(self.content)):
    358                         if (hasattr(self.content[i],'get_interfaces')):
    359                                 for aux_interface in self.content[i].get_interfaces():
    360                                         self.__insert_interface_reference(aux_interface,i)
    361                        
     399                for stanza in self.content:
     400                        if (hasattr(stanza,'get_interfaces')):
     401                                for aux_interface in stanza.get_interfaces():
     402                                        self.__insert_interface_reference(aux_interface,stanza)
     403               
     404
    362405        def get_info_interface(self,interface):
    363406                aux_return = []
    364407                if interface in self.interface_mapping:
    365                         for x in self.interface_mapping[interface]:
    366                                 aux_return.append(self.content[x].print_stanza())
     408                        for stanza in self.interface_mapping[interface]:
     409                                aux_return.append(stanza.print_stanza())
    367410                return aux_return
    368        
     411
     412        def get_real_list_interfaces(self):
     413                list_of_interfaces = []
     414                if os.path.exists('/proc/net/dev'):
     415                        f = open('/proc/net/dev','r')
     416                        lines = f.readlines()
     417                        for x in lines[2:       ]:
     418                                try:
     419                                        list_of_interfaces.append(x.split(':')[0].strip())
     420                                except:
     421                                        pass
     422                return list_of_interfaces
     423
    369424        def get_list_interfaces(self):
    370425                return self.interface_mapping.keys()
    371        
     426
    372427        def change_to_dhcp(self,interface):
    373                 for x in self.interface_mapping[interface]:
    374                         if (hasattr(self.content[x],'change_to_dhcp')):
    375                                 self.content[x].change_to_dhcp()
    376        
     428                for stanza in self.interface_mapping[interface]:
     429                        if (hasattr(stanza,'change_to_dhcp')):
     430                                stanza.change_to_dhcp()
     431
    377432        def change_to_static(self,interface,options):
    378                 for x in self.interface_mapping[interface]:
    379                         if (hasattr(self.content[x],'change_to_static')):
     433                for stanza in self.interface_mapping[interface]:
     434                        if (hasattr(stanza,'change_to_static')):
    380435                                address = options.pop('address')
    381436                                netmask = options.pop('netmask')
    382437                                list_options = []
    383438                                for key in options.keys():
    384                                         list_options.append(str(key) + " " + options.pop(key))
    385                                 self.content[x].change_to_static(address,netmask,list_options)
    386         #def change_to_static
    387        
     439                                        list_options.append(str(key) + " " + options[key])
     440                                stanza.change_to_static(address,netmask,list_options)
     441       
     442        def update_dns(self,interface,dns):
     443                for stanza in self.interface_mapping[interface]:
     444                        if (hasattr(stanza,'remove_option')):
     445                                stanza.remove_option('dns-nameservers',startswith=True)
     446                                for key in dns:
     447                                        if key.strip() != "" :
     448                                                stanza.set_option('dns-nameservers ' + key)
     449
    388450        def change_option_sysctl(self,file_path,needle,value):
    389451                if (os.path.exists(file_path)):
     
    404466                        f.write(value+"\n")
    405467                f.close()
    406        
     468
    407469        def enable_forwarding_ipv4(self,persistent=False):
    408470                if (persistent):
     
    411473                f.write('1')
    412474                f.close()
    413         #def enable_forwarding_ipv4
    414        
     475
    415476        def disable_forwarding_ipv4(self,persistent=False):
    416477                if (persistent):
     
    419480                f.write('0')
    420481                f.close()
    421         #def enable_forwarding_ipv4
    422        
     482
    423483        def enable_forwarding_ipv6(self,persistent=False):
    424484                if (persistent):
     
    427487                f.write('1')
    428488                f.close()
    429         #def enable_forwarding_ipv6
    430        
     489
    431490        def disable_forwarding_ipv6(self,persistent=False):
    432491                if (persistent):
     
    435494                f.write('0')
    436495                f.close()
    437         #def disable_forwarding_ipv6
    438        
     496
    439497        def is_enable_forwarding_ipv4(self):
    440498                try:
     
    451509                else:
    452510                        return True
    453        
     511
    454512        def is_enable_forwarding_ipv6(self):
    455513                try:
     
    466524                else:
    467525                        return True
    468                
     526
    469527        def enable_nat(self,interfaces_list,internal_interfaces_script):
    470                 if (type(interfaces_list) != type([])):
     528                if not isinstance(interfaces_list,list):
     529                        raise Exception("interfaces must be list")
     530                for x in interfaces_list:
     531                        if x in self.interface_mapping.keys():
     532                                for stanza in self.interface_mapping[x]:
     533                                        if(stanza.__class__.__name__ == 'StanzaIface'):
     534                                                stanza.set_option('up enablenat A ' + internal_interfaces_script,unique=True)
     535                        else:
     536                                raise Exception("Interface " + x  + " is not defined on " + self.path)
     537
     538        def disable_nat(self, interfaces_list):
     539                if not isinstance(interfaces_list,list):
    471540                        raise Exception("interfaces must be list")
    472541                for x in interfaces_list:
    473542                        if ( x in self.interface_mapping.keys()):
    474                                 for i in self.interface_mapping[x]:
    475                                         if(self.content[i].__class__.__name__ == 'StanzaIface'):
    476                                                 self.content[i].set_option('up enablenat A ' + internal_interfaces_script,unique=True)
     543                                for stanza in self.interface_mapping[x]:
     544                                        if(stanza.__class__.__name__ == 'StanzaIface'):
     545                                                stanza.remove_option('up enablenat',startswith=True)
    477546                        else:
    478547                                raise Exception("Interface " + x  + " is not defined on " + self.path)
    479        
    480         def disable_nat(self, interfaces_list):
    481                 if (type(interfaces_list) != type([])):
    482                         raise Exception("interfaces must be list")
    483                 for x in interfaces_list:
    484                         if ( x in self.interface_mapping.keys()):
    485                                 for i in self.interface_mapping[x]:
    486                                         if(self.content[i].__class__.__name__ == 'StanzaIface'):
    487                                                 self.content[i].remove_option('up enablenat',startswith=True)
    488                         else:
    489                                 raise Exception("Interface " + x  + " is not defined on " + self.path)
    490        
     548
    491549        def insert_stanza(self, stanza):
    492550                if stanza.__class__.__name__ in ['StanzaIface','StanzaAuto','StanzaComment','StanzaMapping','StanzaSource']:
     
    494552                        if (hasattr(stanza,'get_interfaces')):
    495553                                for aux_interface in stanza.get_interfaces():
    496                                         self.__insert_interface_reference(aux_interface,len(self.content)-1)
     554                                        self.__insert_interface_reference(aux_interface,stanza)
    497555                else:
    498556                        raise Exception("Stanza not supported")
    499         #def insert_stanza
     557
    500558        def get_nat_persistent(self,interface):
    501                 for i in self.interface_mapping[str(interface)]:
    502                         if(self.content[i].__class__.__name__ == 'StanzaIface'):
    503                                 for x in self.content[i].options:
     559                for stanza in self.interface_mapping[str(interface)]:
     560                        if(stanza.__class__.__name__ == 'StanzaIface'):
     561                                for x in stanza.options:
    504562                                        if 'up enablenat' in x:
    505563                                                return True
    506564                return False
    507                                
    508                
    509         #def get_nat_persistent
    510565
    511566        def get_routing_persistent(self, type):
     
    528583                                except Exception:
    529584                                        return False
     585
     586        def delete_all_interface(self,interface):
     587                try:
     588                        self.__delete_stanza(interface,StanzaBasic)
     589                        return True
     590                except:
     591                        return False
    530592               
    531         #def get_routing_persistent
    532        
    533 
     593        def auto_toggle(self,interface,status):
     594                if status:
     595                        if interface in self.interface_mapping:
     596                                for stanza in self.interface_mapping[interface]:
     597                                        if isinstance(stanza,StanzaAuto):
     598                                                return True
     599                        aux_stanza = StanzaAuto([interface])
     600                        self.insert_stanza(aux_stanza)
     601                else:
     602                        self.delete_auto(interface)
     603                        return True
     604
     605        def delete_auto(self,interface):
     606                try:
     607                        self.__delete_stanza(interface,StanzaAuto)
     608                        return True
     609                except:
     610                        return False
     611
     612        def __delete_stanza(self,interface,objectclass):
     613                if interface in self.interface_mapping.keys():
     614                        for index in range(len(self.interface_mapping[interface]) -1 , -1 , -1):
     615                                stanza = self.interface_mapping[interface][index]
     616                                if isinstance(stanza,objectclass):
     617                                        self.__delete_interface(interface,stanza)
     618                        if len(self.interface_mapping[interface]) <= 0:
     619                                self.interface_mapping.pop(interface)
     620
     621        def __delete_interface(self,interface,stanza):
     622                stanza.remove_interface(interface)
     623                self.interface_mapping[interface].remove(stanza)
     624                if len(stanza.get_interfaces()) <= 0 :
     625                        self.content.remove(stanza)
     626               
Note: See TracChangeset for help on using the changeset viewer.