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

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

adding delete_interfaces_in_range functionality

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