source: n4d-network/trunk/fuentes/install/usr/share/n4d/python-plugins/NetworkManager.py @ 4515

Last change on this file since 4515 was 4515, checked in by hectorgh, 2 years ago

adding ip addr flush when configuring interfaces

File size: 10.4 KB
Line 
1import lliurex.net
2import lliurex.interfacesparser
3import subprocess
4import os
5import tempfile
6import shutil
7import time
8import tarfile
9class NetworkManager:
10        def __init__(self):
11                self.path_interfaces = '/etc/network/interfaces'
12                self.interfaces = lliurex.interfacesparser.InterfacesParser()
13                self.interfaces.load(self.path_interfaces)
14                self.backup_files=["/etc/network/interfaces", "/etc/init/network-manager.override"]
15                self.rules_file="/etc/udev/rules.d/70-persistent-net.rules"
16               
17               
18        #def __init__
19        def startup(self,options):
20                self.internal_interface = objects['VariablesManager'].get_variable('INTERNAL_INTERFACE')
21                self.external_interface = objects['VariablesManager'].get_variable('EXTERNAL_INTERFACE')
22        #def startup
23       
24        def get_interfaces(self):
25                return {'status':True,'msg':[x['name'] for x in lliurex.net.get_devices_info()]}
26        #def get_interfaces
27       
28        def get_interfaces_network_file(self):
29                return {'status':True,'msg':self.interfaces.get_list_interfaces()}
30        #def get_interfaces_network_file
31       
32       
33
34        def load_network_file(self):
35                try:
36                        self.interfaces.load('/etc/network/interfaces')
37                except Exception as e:
38                        if "not exists" in e.message :
39                                return {'status':False,'msg':'File not exist'}
40               
41                return {'status':True,'msg':'Reload file'}
42        #def load_network_file
43       
44        def set_internal_interface(self, interface):
45                objects['VariablesManager'].init_variable('INTERNAL_INTERFACE',{'internal_interface':interface})
46                self.internal_interface = interface
47               
48                ip = None
49                netmask = None
50                listinfo = self.interfaces.get_info_interface(interface)
51                for stanza in listinfo:
52                        if(stanza.__class__.__name__ == 'StanzaIface'):
53                                if (stanza.method == 'static' ):
54                                        for option in stanza.options:
55                                                if (option.startswith('address')):
56                                                        try:
57                                                                ip = option.split(" ")[1]
58                                                        except Exception as e:
59                                                                pass
60                                                if (option.startswith('netmask')):
61                                                        try:
62                                                                netmask = option.split(" ")[1]
63                                                        except Exception as e:
64                                                                pass
65                if(ip == None):
66                        ip = lliurex.net.get_ip(interface)
67                if(netmask == None):
68                        netmask = lliurex.net.get_netmask(interface)
69                       
70                if (ip != None and netmask != None):
71                        objects['VariablesManager'].init_variable('INTERNAL_NETWORK',{'ip':ip,'netmask':netmask})
72                        objects['VariablesManager'].init_variable('INTERNAL_MASK',{'internal_mask':netmask})
73                        objects['VariablesManager'].init_variable('SRV_IP',{'ip':ip})
74                return {'status':True,'msg':'internal interface'}
75        #def set_internal_interfaces
76
77        def set_external_interface(self, interface):
78                objects['VariablesManager'].init_variable('EXTERNAL_INTERFACE',{'external_interface':interface})
79                self.external_interface = interface
80                return {'status':True,'msg':'external interface'}
81        #def set_external_interface
82
83        def interface_dhcp(self, interface, otf):
84                if interface == self.internal_interface:
85                        return {'status':False,'msg':'Interface ' + interface + " is impossible set to dhcp"}
86                if otf:
87                        os.system('dhclient ' + interface)
88               
89                if interface in self.interfaces.get_list_interfaces():
90                        self.interfaces.change_to_dhcp(interface)
91                else:
92                        aux_stanza_auto = lliurex.interfacesparser.StanzaAuto([interface])
93                        aux_stanza_dhcp = lliurex.interfacesparser.StanzaIface([interface],"inet dhcp")
94                        self.interfaces.insert_stanza(aux_stanza_auto)
95                        self.interfaces.insert_stanza(aux_stanza_dhcp)
96                self.interfaces.write_file(self.path_interfaces)
97                return {'status':True,'msg':'Interface ' + interface + " has been changed to dhcp"}
98       
99        def interface_static(self, interface, ip,netmask,otf, gateway=None,dnssearch=None):
100                if otf:
101                        os.system('ifconfig '+ interface+' ' + ip + ' netmask ' + netmask)
102                        if gateway != None:
103                                os.system('route add default gw ' + gateway)
104                if  interface in self.interfaces.get_list_interfaces():
105                        options = {'address':ip ,'netmask':netmask}
106                        if gateway != None:
107                                options['gateway'] = gateway
108                        if dnssearch != None:
109                                options['dns-search'] = dnssearch
110                        self.interfaces.change_to_static(interface,options)
111                else:
112                       
113                        options = []
114                        if gateway != None:
115                                options.append("gateway " + gateway)
116                        if dnssearch != None:
117                                options.append("dns-search " + dnssearch)
118                        aux_stanza_auto = lliurex.interfacesparser.StanzaAuto([interface])
119                        aux_stanza_static = lliurex.interfacesparser.StanzaIface([interface],"inet dhcp")
120                        aux_stanza_static.change_to_static(ip,netmask,options)
121                        self.interfaces.insert_stanza(aux_stanza_auto)
122                        self.interfaces.insert_stanza(aux_stanza_static)
123               
124                self.interfaces.write_file(self.path_interfaces)
125                if interface == self.internal_interface:
126                        objects['VariablesManager'].init_variable('INTERNAL_NETWORK',{'ip':ip,'netmask':netmask})
127                        objects['VariablesManager'].init_variable('INTERNAL_MASK',{'internal_mask':netmask})
128                        objects['VariablesManager'].init_variable('SRV_IP',{'ip':ip})
129                       
130                        # Restarting internal interface. Initialization behaves better this way
131                        os.system("ip addr flush dev %s"%interface)
132                        os.system("ifdown %s; ifup %s"%(interface,interface))
133               
134               
135                return {'status':True,'msg':'Interface ' + interface + " has been changed to static "}
136       
137       
138        def get_info_eth(self,eth):
139                if type(eth) == type(""):
140                        return {'status':True,'msg':lliurex.net.get_device_info(eth)}
141                else:
142                        return {'status':False,'msg':'eth must to be string'}
143        #def get_info_eth
144       
145        def set_nat(self, enable=True, persistent=False , eth=None):
146                if eth == None:
147                        if self.external_interface == None:
148                                return {'status':False,'msg':'External interface is not defined'}
149                        else:
150                                eth = self.external_interface
151                if persistent:
152                        try:
153                                if enable:
154                                        self.interfaces.enable_nat([eth],'/usr/share/n4d-network/list_internal_interfaces')
155                                else:
156                                        self.interfaces.disable_nat([eth])
157                        except Exception as e:
158                                return {'status':False,'msg':e.message}
159                        self.interfaces.write_file(self.path_interfaces)
160                script = ['enablenat']
161                if enable:
162                        script.append('A')
163                else:
164                        script.append('D')
165                script.append('/usr/share/n4d-network/list_internal_interfaces')
166                script.append(eth)
167                p = subprocess.Popen(script,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
168                result = p.communicate()[0]
169                return {'status':True,'msg':'nat is set'}
170        #def set_nat
171       
172        def get_nat(self):
173                if self.external_interface == None:
174                        return {'status':False,'msg':'External interface is not defined'}
175                p = subprocess.Popen(['iptables-save','-t','nat'],stdout=subprocess.PIPE,stdin=subprocess.PIPE)
176                output = p.communicate()[0].split('\n')
177                needle = "-A POSTROUTING -o "+self.external_interface+" -j MASQUERADE"
178                if (needle in output):
179                        return {'status':True,'msg':'Nat is activated'}
180                else:
181                        return {'status':False,'msg':'Nat is not activated'}
182        #def get_nat
183       
184        def set_routing(self, enable=True, persistent=False):
185                if enable:
186                        self.interfaces.enable_forwarding_ipv4(persistent)
187                else:
188                        self.interfaces.disable_forwarding_ipv4(persistent)
189                return {'status':True,'msg': 'routing set'}
190        #def set_routing
191       
192        def get_routing(self):
193                ret=self.interfaces.is_enable_forwarding_ipv4()
194                if ret:
195                        msg="Routing is enabled"
196                else:
197                        msg="Routing is disabled"
198                return {'status':ret,'msg':msg}
199        #def get_routing
200
201        def get_nat_persistence(self):
202                if self.external_interface != None:
203                        result = self.interfaces.get_nat_persistent(self.external_interface)
204                        status = 'enabled' if result else 'disabled'
205                else:
206                        result = False
207                        status = 'disabled'
208                return {'status': result,'msg' : 'Nat persistence is ' + status }
209        #def get_nat_persistent
210
211        def get_routing_persistence(self):
212                result = self.interfaces.get_routing_persistent('ipv4')
213                if result :
214                        return {'status':result,'msg':'Routing persistent is enabled'}
215                else:
216                        return {'status':result,'msg':'Routing persistent is disabled'}
217        #def get_routing_persistent
218
219        def disable_network_manager(self):
220                return {'status':False,'msg': 'Removed dependency of upstart-manager from lliurex-disable-upstart-services, need to fix? /usr/share/n4d/python-plugins/NetworkManager.py from n4d-network'}
221                script = ['/usr/sbin/upstart-manager','network-manager']
222                p = subprocess.Popen(script,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
223                result = p.communicate()[0]
224                script = ['stop','network-manager']
225                p = subprocess.Popen(script,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
226                result = p.communicate()[0]
227                return {'status':True,'msg': 'Network Manager is disabled ^_^'}
228        #def disable_network_manager
229       
230        def restart_interfaces(self):
231                result = os.system('/etc/init.d/networking restart')
232               
233                for interface in lliurex.net.get_devices_info():
234                        os.system("ip addr flush dev %s"%interface["name"])
235                        os.system("ifdown %s;ifup %s"%(interface["name"],interface["name"]))
236                       
237                if (result == 0):
238                        return {'status':True,'msg':'network is restarted ok'}
239                else:
240                        return {'status':False,'msg':'network has a problem. Please check file'}
241        #def restart_interfaces
242       
243        def makedir(self,dir_path=None):
244               
245                if not os.path.isdir(dir_path):
246                        os.makedirs(dir_path)
247               
248                return [True]
249               
250        # def makedir
251       
252       
253        def backup(self,dir_path="/backup"):
254               
255               
256                try:
257               
258                        self.makedir(dir_path)
259                        file_path=dir_path+"/"+get_backup_name("NetworkManager")
260                       
261                               
262                        tar=tarfile.open(file_path,"w:gz")
263                       
264                        for f in self.backup_files:
265                                if os.path.exists(f):
266                                        tar.add(f)
267                                       
268                        #for
269                       
270                        tar.close()
271                        print "Backup generated in %s" % file_path     
272                        return [True,file_path]
273                       
274                       
275                except Exception as e:
276                                print "Backup failed", e
277                                return [False,str(e)]
278               
279        #def backup
280       
281        def restore(self,file_path=None):
282               
283                               
284               
285                #Ordeno de manera alfabetica el directorio y busco el fichero que tiene mi cadena
286                if file_path==None:
287                        dir_path="/backup"
288                        for f in sorted(os.listdir(dir_path),reverse=True):
289                               
290                                if "NetworkManager" in f:
291                                        file_path=dir_path+"/"+f
292                                        break
293                       
294                #Descomprimo el fichero y solo las cadenas que espero encontrar son las que restauro, reiniciando el servicio
295               
296                print "Trabajare con este fichero", file_path
297                try:
298                        if os.path.exists(file_path):
299                                tmp_dir=tempfile.mkdtemp()
300                                tar=tarfile.open(file_path)
301                                tar.extractall(tmp_dir)
302                                tar.close
303                                for f in self.backup_files:
304                                                tmp_path=tmp_dir+f
305                                                if os.path.exists(tmp_path):
306                                                        shutil.copy(tmp_path,f)
307                                                       
308                               
309                                               
310                                if os.path.exists(self.rules_file):
311                                        os.remove(self.rules_file)
312                                       
313                        os.system("/etc/init.d/networking restart")
314                        print "File is restored in %s" % self.backup_files
315                       
316                        return [True,""]
317               
318               
319                except Exception as e:
320                       
321                        print "Restored failed", e
322                        return [False,str(e)]
323               
324                pass
325               
326        #def restore
327       
328       
329if __name__ == '__main__':
330        e = NetworkManager()
331        print e.get_interfaces()
Note: See TracBrowser for help on using the repository browser.