def setup(self):
require_user('root')
require_executable('busybox')
self.ip = IPDB()
# create internal network
self.if1 = uifname()
self.if2 = uifname()
self.ip.create(kind='veth', ifname=self.if1, peer=self.if2).commit()
# set interfaces up
with self.ip.interfaces[self.if1] as i:
i.add_ip('172.16.101.1/24')
i.up()
with self.ip.interfaces[self.if2] as i:
i.up()
# prepare configuration for udhcpd
with open('udhcpd.conf.in', 'r') as conf_in:
with open('udhcpd.conf', 'w') as conf_out:
conf_out.write('interface %s\n' % self.if1)
conf_out.write(conf_in.read())
# run busybox dhcp server on $if1
with open(os.devnull, 'w') as fnull:
subprocess.check_call(['busybox', 'udhcpd', 'udhcpd.conf'],
stdout=fnull,
stderr=fnull)
def test_move_ns_fd(self):
foo = str(uuid4())
bar = str(uuid4())
ifA = uifname()
ifB = uifname()
netnsmod.create(foo)
netnsmod.create(bar)
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=ifA, kind='veth', peer=ifB).commit()
assert ifA in ip.interfaces.keys()
assert ifB in ip.interfaces.keys()
with ip.interfaces[ifB] as intf:
intf.net_ns_fd = bar
assert ifA in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(bar)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB in ip.interfaces.keys()
ip.interfaces[ifB].remove().commit()
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(foo)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
netnsmod.remove(foo)
netnsmod.remove(bar)
def test_create_peer_attrs(self):
foo = str(uuid4())
bar = str(uuid4())
ifA = uifname()
ifB = uifname()
netnsmod.create(foo)
netnsmod.create(bar)
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=ifA,
kind='veth',
peer={'ifname': ifB,
'net_ns_fd': bar}).commit()
assert ifA in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(bar)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB in ip.interfaces.keys()
ip.interfaces[ifB].remove().commit()
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(foo)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
netnsmod.remove(foo)
netnsmod.remove(bar)
def test_move_ns_fd(self):
foo = str(uuid4())
bar = str(uuid4())
ifA = uifname()
ifB = uifname()
netnsmod.create(foo)
netnsmod.create(bar)
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=ifA, kind='veth', peer=ifB).commit()
assert ifA in ip.interfaces.keys()
assert ifB in ip.interfaces.keys()
with ip.interfaces[ifB] as intf:
intf.net_ns_fd = bar
assert ifA in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(bar)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB in ip.interfaces.keys()
ip.interfaces[ifB].remove().commit()
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(foo)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
netnsmod.remove(foo)
netnsmod.remove(bar)
def setup(self):
require_user('root')
require_executable('busybox')
self.ip = IPDB()
# create internal network
self.if1 = uifname()
self.if2 = uifname()
self.ip.create(kind='veth', ifname=self.if1, peer=self.if2).commit()
# set interfaces up
with self.ip.interfaces[self.if1] as i:
i.add_ip('172.16.101.1/24')
i.up()
with self.ip.interfaces[self.if2] as i:
i.up()
# prepare configuration for udhcpd
with open('udhcpd.conf.in', 'r') as conf_in:
with open('udhcpd.conf', 'w') as conf_out:
conf_out.write('interface %s\n' % self.if1)
conf_out.write(conf_in.read())
# run busybox dhcp server on $if1
with open(os.devnull, 'w') as fnull:
subprocess.check_call(['busybox', 'udhcpd', 'udhcpd.conf'],
stdout=fnull,
stderr=fnull)
def test_veth_simple(self):
ifname = uifname()
peername = uifname()
(self
.ndb
.interfaces
.create(ifname=ifname, peer=peername, kind='veth')
.commit())
iflink = self.ndb.interfaces[ifname]['link']
plink = self.ndb.interfaces[peername]['link']
assert iflink == self.ndb.interfaces[peername]['index']
assert plink == self.ndb.interfaces[ifname]['index']
assert grep('%s ip link show' % self.ssh, pattern=ifname)
assert grep('%s ip link show' % self.ssh, pattern=peername)
(self
.ndb
.interfaces[ifname]
.remove()
.commit())
assert not grep('%s ip link show' % self.ssh, pattern=ifname)
assert not grep('%s ip link show' % self.ssh, pattern=peername)
def test_create_peer_attrs(self):
foo = str(uuid4())
bar = str(uuid4())
ifA = uifname()
ifB = uifname()
netnsmod.create(foo)
netnsmod.create(bar)
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=ifA,
kind='veth',
peer={
'ifname': ifB,
'net_ns_fd': bar
}).commit()
assert ifA in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(bar)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB in ip.interfaces.keys()
ip.interfaces[ifB].remove().commit()
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
with IPDB(nl=NetNS(foo)) as ip:
assert ifA not in ip.interfaces.keys()
assert ifB not in ip.interfaces.keys()
netnsmod.remove(foo)
netnsmod.remove(bar)
def test_veth_simple(self):
ifname = uifname()
peername = uifname()
spec = self.getspec(ifname=ifname,
peer=peername,
kind='veth')
(self
.ndb
.interfaces
.create(**spec)
.commit())
spec_ifl = self.getspec(ifname=ifname)
spec_pl = self.getspec(ifname=peername)
iflink = self.ndb.interfaces[spec_ifl]['link']
plink = self.ndb.interfaces[spec_pl]['link']
assert iflink == self.ndb.interfaces[spec_pl]['index']
assert plink == self.ndb.interfaces[spec_ifl]['index']
assert grep('%s ip link show' % self.ssh, pattern=ifname)
assert grep('%s ip link show' % self.ssh, pattern=peername)
(self
.ndb
.interfaces[spec_ifl]
.remove()
.commit())
assert not grep('%s ip link show' % self.ssh, pattern=ifname)
assert not grep('%s ip link show' % self.ssh, pattern=peername)
def test_view_cache(self):
require_user('root')
log_id = str(uuid.uuid4())
ifname1 = uifname()
ifname2 = uifname()
with NDB(log='../ndb-%s-%s.log' % (os.getpid(), log_id),
rtnl_debug=True) as ndb:
# the cache is empty from the beginning
assert len(list(ndb.interfaces.cache)) == 0
# create test interfaces
ndb.interfaces.create(ifname=ifname1, kind='dummy').commit()
ndb.interfaces.create(ifname=ifname2, kind='dummy').commit()
# the interfaces must not be cached
assert len(list(ndb.interfaces.cache)) == 0
# setup the cache expiration time
ce = config.cache_expire
config.cache_expire = 1
# access the interfaces via __getitem__()
assert ndb.interfaces[ifname1] is not None
assert ndb.interfaces[ifname2] is not None
# both must be in the cache
assert len(list(ndb.interfaces.cache)) == 2
# expire the cache
time.sleep(1)
# access the second interface to trigger the cache invalidation
assert ndb.interfaces[ifname2] is not None
# only ifname2 must remain in the cache
assert len(list(ndb.interfaces.cache)) == 1
# restore the environment
config.cache_expire = ce
ndb.interfaces[ifname1].remove().commit()
ndb.interfaces[ifname2].remove().commit()
def test_veth_spec(self):
ifname = uifname()
peername = uifname()
nsname = str(uuid.uuid4())
(self
.ndb
.sources
.add(netns=nsname))
spec = self.getspec(**{'ifname': ifname,
'kind': 'veth',
'peer': {'ifname': peername,
'address': '00:11:22:33:44:55',
'net_ns_fd': nsname}})
(self
.ndb
.interfaces
.create(**spec)
.commit())
(self
.ndb
.interfaces
.wait(target=nsname, ifname=peername))
iflink = (self
.ndb
.interfaces[self.getspec(ifname=ifname)]['link'])
plink = (self
.ndb
.interfaces[{'target': nsname,
'ifname': peername}]['link'])
assert iflink == (self
.ndb
.interfaces[{'target': nsname,
'ifname': peername}]['index'])
assert plink == (self
.ndb
.interfaces[self.getspec(ifname=ifname)]['index'])
assert grep('%s ip link show' % self.ssh, pattern=ifname)
assert not grep('%s ip link show' % self.ssh, pattern=peername)
(self
.ndb
.interfaces[self.getspec(ifname=ifname)]
.remove()
.commit())
assert not grep('%s ip link show' % self.ssh, pattern=ifname)
assert not grep('%s ip link show' % self.ssh, pattern=peername)
(self
.ndb
.sources
.remove(nsname))
netns.remove(nsname)
def create_interfaces(self):
# dummy interface
if_dummy = uifname()
if_vlan_stag = uifname()
if_vlan_ctag = uifname()
if_bridge = uifname()
if_port = uifname()
if_addr1 = self.ifaddr()
if_addr2 = self.ifaddr()
ret = []
ret.append(
self.ndb.interfaces.create(ifname=if_dummy,
kind='dummy').commit()['index'])
ret.append(
self.ndb.interfaces.create(
ifname=if_vlan_stag,
link=self.ndb.interfaces[if_dummy]['index'],
vlan_id=101,
vlan_protocol=0x88a8,
kind='vlan').commit()['index'])
ret.append(
self.ndb.interfaces.create(
ifname=if_vlan_ctag,
link=self.ndb.interfaces[if_vlan_stag]['index'],
vlan_id=1001,
vlan_protocol=0x8100,
kind='vlan').commit()['index'])
ret.append(
self.ndb.interfaces.create(ifname=if_bridge,
kind='bridge').commit()['index'])
ret.append(
self.ndb.interfaces.create(
ifname=if_port,
master=self.ndb.interfaces[if_bridge]['index'],
kind='dummy').commit()['index'])
(self.ndb.interfaces[if_bridge].ipaddr.create(address=if_addr1,
prefixlen=24).commit())
(self.ndb.interfaces[if_bridge].ipaddr.create(address=if_addr2,
prefixlen=24).commit())
self.if_bridge = if_bridge
return ret
def test_create(self):
require_user('root')
nsid = str(uuid4())
ipdb_main = IPDB()
ipdb_test = IPDB(nl=NetNS(nsid))
if1 = uifname()
if2 = uifname()
# create VETH pair
ipdb_main.create(ifname=if1, kind='veth', peer=if2).commit()
# move the peer to netns
with ipdb_main.interfaces[if2] as veth:
veth.net_ns_fd = nsid
# assign addresses
with ipdb_main.interfaces[if1] as veth:
veth.add_ip('172.16.200.1/24')
veth.up()
with ipdb_test.interfaces[if2] as veth:
veth.add_ip('172.16.200.2/24')
veth.up()
# ping peer
try:
with open('/dev/null', 'w') as fnull:
subprocess.check_call(['ping', '-c', '1', '172.16.200.2'],
stdout=fnull,
stderr=fnull)
ret_ping = True
except Exception:
ret_ping = False
# check ARP
time.sleep(0.5)
ret_arp = '172.16.200.1' in list(ipdb_test.interfaces[if2].neighbours)
# ret_arp = list(ipdb_test.interfaces.v0p1.neighbours)
# cleanup
ipdb_main.interfaces[if1].remove().commit()
ipdb_main.release()
ipdb_test.release()
netnsmod.remove(nsid)
assert ret_ping
assert ret_arp
assert nsid not in netnsmod.listnetns()
def _ports_mtu_race(self, kind):
port1 = (self.ip.create(ifname=uifname(), kind='dummy',
mtu=1280).commit())
port2 = (self.ip.create(ifname=uifname(), kind='dummy').commit())
master = (self.ip.create(ifname=uifname(), kind=kind).commit())
try:
master.add_port(port1).commit()
master.add_port(port2).commit()
except:
raise
finally:
port1.remove().commit()
port2.remove().commit()
master.remove().commit()
def test_create(self):
require_user('root')
nsid = str(uuid4())
ipdb_main = IPDB()
ipdb_test = IPDB(nl=NetNS(nsid))
if1 = uifname()
if2 = uifname()
# create VETH pair
ipdb_main.create(ifname=if1, kind='veth', peer=if2).commit()
# move the peer to netns
with ipdb_main.interfaces[if2] as veth:
veth.net_ns_fd = nsid
# assign addresses
with ipdb_main.interfaces[if1] as veth:
veth.add_ip('172.16.200.1/24')
veth.up()
with ipdb_test.interfaces[if2] as veth:
veth.add_ip('172.16.200.2/24')
veth.up()
# ping peer
try:
with open('/dev/null', 'w') as fnull:
subprocess.check_call(['ping', '-c', '1', '172.16.200.2'],
stdout=fnull, stderr=fnull)
ret_ping = True
except Exception:
ret_ping = False
# check ARP
time.sleep(0.5)
ret_arp = '172.16.200.1' in list(ipdb_test.interfaces[if2].neighbours)
# ret_arp = list(ipdb_test.interfaces.v0p1.neighbours)
# cleanup
ipdb_main.interfaces[if1].remove().commit()
ipdb_main.release()
ipdb_test.release()
netnsmod.remove(nsid)
assert ret_ping
assert ret_arp
assert nsid not in netnsmod.listnetns()
def test_basic(self):
ifname = uifname()
ifaddr1 = self.ifaddr()
ifaddr2 = self.ifaddr()
ifaddr3 = self.ifaddr()
(self
.ndb
.interfaces
.create(target=self.netns, ifname=ifname, kind='dummy')
.ipaddr
.create(address=ifaddr1, prefixlen=24)
.create(address=ifaddr2, prefixlen=24)
.create(address=ifaddr3, prefixlen=24)
.commit())
with NDB(sources=[{'target': 'localhost',
'netns': self.netns,
'kind': 'netns'}]) as ndb:
if_idx = ndb.interfaces[ifname]['index']
addr1_idx = ndb.addresses['%s/24' % ifaddr1]['index']
addr2_idx = ndb.addresses['%s/24' % ifaddr2]['index']
addr3_idx = ndb.addresses['%s/24' % ifaddr3]['index']
assert if_idx == addr1_idx == addr2_idx == addr3_idx
def setup(self):
self.ifname = uifname()
self.ip = IPDB(mode='direct')
try:
self.ip.create(ifname=self.ifname, kind='dummy')
except:
pass
def _create(self, kind, **kwarg):
name = uifname()
self.ip.link('add', ifname=name, kind=kind, **kwarg)
devs = self.ip.link_lookup(ifname=name)
assert devs
self.ifaces.extend(devs)
return (name, devs[0])
def interface_event():
with open(os.devnull, 'w') as fnull:
p0 = uifname()
add_command = 'ip link add dev %s type dummy' % p0
del_command = 'ip link del dev %s' % p0
subprocess.call(add_command.split(), stdout=fnull, stderr=fnull)
subprocess.call(del_command.split(), stdout=fnull, stderr=fnull)
def test_move_ns_pid(self):
foo = str(uuid4())
bar = str(uuid4())
ifA = uifname()
netnsmod.create(foo)
netnsmod.create(bar)
ns_foo = IPDB(nl=NetNS(foo))
ns_bar = IPDB(nl=NetNS(bar))
try:
ns_foo.create(ifname=ifA, kind='dummy').commit()
with ns_foo.interfaces[ifA] as iface:
iface.net_ns_pid = ns_bar.nl.server.pid
assert ifA in ns_bar.interfaces.keys()
assert ifA not in ns_foo.interfaces.keys()
with ns_bar.interfaces[ifA] as iface:
iface.net_ns_pid = ns_foo.nl.server.pid
assert ifA not in ns_bar.interfaces.keys()
assert ifA in ns_foo.interfaces.keys()
finally:
ns_foo.release()
ns_bar.release()
netnsmod.remove(foo)
netnsmod.remove(bar)
def test_basic(self):
ifname = uifname()
ifaddr1 = self.ifaddr()
ifaddr2 = self.ifaddr()
ifaddr3 = self.ifaddr()
(self
.ndb
.interfaces
.create(target=self.netns, ifname=ifname, kind='dummy')
.ipaddr
.create(address=ifaddr1, prefixlen=24)
.create(address=ifaddr2, prefixlen=24)
.create(address=ifaddr3, prefixlen=24)
.commit())
with NDB(sources=[{'target': 'localhost',
'netns': self.netns,
'kind': 'netns'}]) as ndb:
if_idx = ndb.interfaces[ifname]['index']
addr1_idx = ndb.addresses['%s/24' % ifaddr1]['index']
addr2_idx = ndb.addresses['%s/24' % ifaddr2]['index']
addr3_idx = ndb.addresses['%s/24' % ifaddr3]['index']
assert if_idx == addr1_idx == addr2_idx == addr3_idx
def test_move(self):
ifname = uifname()
ifaddr = self.ifaddr()
# create the interfaces
(self
.ndb
.interfaces
.create(ifname=ifname, kind='dummy')
.commit())
# move it to a netns
(self
.ndb
.interfaces[ifname]
.set('net_ns_fd', self.netns)
.commit())
# setup the interface only when it is moved
(self
.ndb
.interfaces
.wait(target=self.netns, ifname=ifname)
.set('state', 'up')
.set('address', '00:11:22:33:44:55')
.ipaddr
.create(address=ifaddr, prefixlen=24)
.commit())
self._assert_test_view(ifname, ifaddr)
def setup(self):
self.ifname = uifname()
self.ip = IPDB(mode='direct')
try:
self.ip.create(ifname=self.ifname, kind='dummy')
except:
pass
def _create(self, kind, **kwarg):
name = uifname()
self.ip.link('add', ifname=name, kind=kind, **kwarg)
devs = self.ip.link_lookup(ifname=name)
assert devs
self.ifaces.extend(devs)
return (name, devs[0])
def test_move(self):
ifname = uifname()
ifaddr = self.ifaddr()
# create the interfaces
(self
.ndb
.interfaces
.create(ifname=ifname, kind='dummy')
.commit())
# move it to a netns
(self
.ndb
.interfaces[ifname]
.set('net_ns_fd', self.netns)
.commit())
# setup the interface only when it is moved
(self
.ndb
.interfaces
.wait(target=self.netns, ifname=ifname)
.set('state', 'up')
.set('address', '00:11:22:33:44:55')
.ipaddr
.create(address=ifaddr, prefixlen=24)
.commit())
self._assert_test_view(ifname, ifaddr)
def test_context_manager(self):
ifname = uifname()
address = '00:11:22:36:47:58'
spec = self.getspec(ifname=ifname, kind='dummy')
ifobj = (self
.ndb
.interfaces
.create(**spec))
with ifobj:
pass
assert grep('%s ip link show' % self.ssh, pattern=ifname)
with ifobj:
ifobj['state'] = 'up'
ifobj['address'] = address
spec = self.getspec(ifname=ifname)
assert grep('%s ip link show' % self.ssh, pattern=address)
assert self.ndb.interfaces[spec]['state'] == 'up'
with ifobj:
ifobj.remove()
def test_move_ns_pid(self):
foo = str(uuid4())
bar = str(uuid4())
ifA = uifname()
netnsmod.create(foo)
netnsmod.create(bar)
ns_foo = IPDB(nl=NetNS(foo))
ns_bar = IPDB(nl=NetNS(bar))
try:
ns_foo.create(ifname=ifA, kind='dummy').commit()
with ns_foo.interfaces[ifA] as iface:
iface.net_ns_pid = ns_bar.nl.server.pid
assert ifA in ns_bar.interfaces.keys()
assert ifA not in ns_foo.interfaces.keys()
with ns_bar.interfaces[ifA] as iface:
iface.net_ns_pid = ns_foo.nl.server.pid
assert ifA not in ns_bar.interfaces.keys()
assert ifA in ns_foo.interfaces.keys()
finally:
ns_foo.release()
ns_bar.release()
netnsmod.remove(foo)
netnsmod.remove(bar)
def test_commit_barrier(self):
require_user("root")
ifname = uifname()
# barrier 0
try:
ip = IPDB()
config.commit_barrier = 0
ts1 = time.time()
ip.create(ifname=ifname, kind="dummy").commit()
ts2 = time.time()
assert 0 < (ts2 - ts1) < 1
except:
raise
finally:
config.commit_barrier = 0.2
ip.interfaces[ifname].remove().commit()
ip.release()
# barrier 5
try:
ip = IPDB()
config.commit_barrier = 5
ts1 = time.time()
ip.create(ifname=ifname, kind="dummy").commit()
ts2 = time.time()
assert 5 < (ts2 - ts1) < 6
except:
raise
finally:
config.commit_barrier = 0.2
ip.interfaces[ifname].remove().commit()
ip.release()
def setup(self):
self.ifname = uifname()
self.ip = IPDB(mode="direct")
try:
self.ip.create(ifname=self.ifname, kind="dummy")
except:
pass
def test_commit_barrier(self):
require_user('root')
ifname = uifname()
# barrier 0
try:
ip = IPDB()
config.commit_barrier = 0
ts1 = time.time()
ip.create(ifname=ifname, kind='dummy').commit()
ts2 = time.time()
assert 0 < (ts2 - ts1) < 1
except:
raise
finally:
config.commit_barrier = 0.2
ip.interfaces[ifname].remove().commit()
ip.release()
# barrier 5
try:
ip = IPDB()
config.commit_barrier = 5
ts1 = time.time()
ip.create(ifname=ifname, kind='dummy').commit()
ts2 = time.time()
assert 5 < (ts2 - ts1) < 6
except:
raise
finally:
config.commit_barrier = 0.2
ip.interfaces[ifname].remove().commit()
ip.release()
def test_fail(self):
ifname = uifname()
kind = uifname()
ifobj = (self.ndb.interfaces.create(ifname=ifname, kind=kind))
save = dict(ifobj)
try:
ifobj.commit()
except NetlinkError as e:
assert e.code == 95 # Operation not supported
assert save == dict(ifobj)
assert ifobj.state == 'invalid'
def test_create(self):
require_user("root")
ifname = uifname()
assert ifname not in self.ip.interfaces
self.ip.create(ifname=ifname, kind="dummy")
assert ifname in self.ip.interfaces
self.ip.interfaces[ifname].remove()
assert ifname not in self.ip.interfaces
def test_create(self):
require_user('root')
ifname = uifname()
assert ifname not in self.ip.interfaces
self.ip.create(ifname=ifname, kind='dummy')
assert ifname in self.ip.interfaces
self.ip.interfaces[ifname].remove()
assert ifname not in self.ip.interfaces
def setup(self):
require_user("root")
self.l2tp = L2tp()
self.log_id = str(uuid.uuid4())
self.ndb = NDB(
log="../ndb-%s-%s.log" % (os.getpid(), self.log_id),
rtnl_debug=True,
)
self.netif = uifname()
self.l2tpeth0 = uifname()
self.localnet = allocate_network()
self.remotenet = allocate_network()
self.localrange = [str(x) for x in self.localnet]
self.remoterange = [str(x) for x in self.remotenet]
# create the "network" interface
(self.ndb.interfaces.create(ifname=self.netif, kind="dummy").set(
"state", "up").add_ip("%s/24" % (self.localrange[1])).commit())
def test_simple_deps(self):
# register NDB handler to wait for the interface
self.if_simple = uifname()
ifaddr = self.ifaddr()
router = self.ifaddr()
dst = str(self.ipnets[1].network)
#
# simple dummy interface with one address and
# one dependent route
#
(self
.interfaces
.append(self
.ndb
.interfaces
.create(ifname=self.if_simple, kind='dummy')
.set('state', 'up')
.commit()['index']))
(self
.ndb
.addresses
.create(address=ifaddr,
prefixlen=24,
index=self.interfaces[-1])
.commit())
(self
.ndb
.routes
.create(dst=dst, dst_len=24, gateway=router)
.commit())
iface = self.ndb.interfaces[self.if_simple]
# check everything is in place
assert grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh,
pattern='%s.*%s' % (dst, router))
# remove the interface
iface.remove()
iface.commit()
# check there is no interface, no route
assert not grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert not grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert not grep('%s ip route show' % self.ssh,
pattern='%s.*%s' % (dst, router))
# revert the changes using the implicit last_save
iface.rollback()
assert grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh,
pattern='%s.*%s' % (dst, router))
def test_simple_deps(self):
# register NDB handler to wait for the interface
self.if_simple = uifname()
ifaddr = self.ifaddr()
router = self.ifaddr()
dst = str(self.ipnets[1].network)
#
# simple dummy interface with one address and
# one dependent route
#
(self
.interfaces
.append(self
.ndb
.interfaces
.create(ifname=self.if_simple, kind='dummy')
.set('state', 'up')
.commit()['index']))
(self
.ndb
.addresses
.create(address=ifaddr,
prefixlen=24,
index=self.interfaces[-1])
.commit())
(self
.ndb
.routes
.create(dst=dst, dst_len=24, gateway=router)
.commit())
iface = self.ndb.interfaces[self.if_simple]
# check everything is in place
assert grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh,
pattern='%s.*%s' % (dst, router))
# remove the interface
iface.remove()
iface.commit()
# check there is no interface, no route
assert not grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert not grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert not grep('%s ip route show' % self.ssh,
pattern='%s.*%s' % (dst, router))
# revert the changes using the implicit last_save
iface.rollback()
assert grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh,
pattern='%s.*%s' % (dst, router))
def test_create_tuntap(self):
# actually this test checks the nlsocket plugin feedback
# in a pair of remote client/server
foo = str(uuid4())
tun = uifname()
tap = uifname()
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=tun, kind='tuntap', mode='tun').commit()
ip.create(ifname=tap, kind='tuntap', mode='tap').commit()
assert tun in ip.interfaces.keys()
assert tap in ip.interfaces.keys()
ip.interfaces[tun].remove().commit()
ip.interfaces[tap].remove().commit()
assert tun not in ip.interfaces.keys()
assert tap not in ip.interfaces.keys()
netnsmod.remove(foo)
def _create_ipvlan(self, smode):
master = uifname()
ipvlan = uifname()
# create the master link
self.ip.link_create(ifname=master, kind='dummy')
midx = self.ip.link_lookup(ifname=master)[0]
# check modes
# maybe move modes dict somewhere else?
cmode = ifinfmsg.ifinfo.ipvlan_data.modes[smode]
assert ifinfmsg.ifinfo.ipvlan_data.modes[cmode] == smode
# create ipvlan
self.ip.link_create(ifname=ipvlan,
kind='ipvlan',
link=midx,
mode=cmode)
devs = self.ip.link_lookup(ifname=ipvlan)
assert devs
self.ifaces.extend(devs)
def _create_ipvlan(self, smode):
master = uifname()
ipvlan = uifname()
# create the master link
self.ip.link_create(ifname=master, kind='dummy')
midx = self.ip.link_lookup(ifname=master)[0]
# check modes
# maybe move modes dict somewhere else?
cmode = ifinfmsg.ifinfo.ipvlan_data.modes[smode]
assert ifinfmsg.ifinfo.ipvlan_data.modes[cmode] == smode
# create ipvlan
self.ip.link_create(ifname=ipvlan,
kind='ipvlan',
link=midx,
mode=cmode)
devs = self.ip.link_lookup(ifname=ipvlan)
assert devs
self.ifaces.extend(devs)
def test_view_constraints_pipeline(self):
ifname = uifname()
ifaddr = self.ifaddr()
(self.ndb.interfaces.constraint('target', self.netns).create(
ifname=ifname,
kind='dummy').set('address', '00:11:22:33:44:55').set(
'state', 'up').ipaddr.create(address=ifaddr,
prefixlen=24).commit())
self._assert_test_view(ifname, ifaddr)
def test_rename_plus_ipv6(self):
require_user('root')
mtu = 1280 # mtu must be >= 1280 if you plan to use IPv6
txqlen = 2000
nsid = str(uuid4())
ipdb_main = IPDB()
ipdb_test = IPDB(nl=NetNS(nsid))
if1 = uifname()
if2 = uifname()
if3 = uifname()
# create
ipdb_main.create(kind='veth',
ifname=if1,
peer=if2,
mtu=mtu,
txqlen=txqlen).commit()
# move
with ipdb_main.interfaces[if2] as veth:
veth.net_ns_fd = nsid
# set it up
with ipdb_test.interfaces[if2] as veth:
veth.add_ip('fdb3:84e5:4ff4:55e4::1/64')
veth.add_ip('fdff:ffff:ffff:ffc0::1/64')
veth.mtu = mtu
veth.txqlen = txqlen
veth.up()
veth.ifname = if3
veth = ipdb_test.interfaces.get(if3, None)
ipdb_main.release()
ipdb_test.release()
netnsmod.remove(nsid)
# check everything
assert ('fdb3:84e5:4ff4:55e4::1', 64) in veth.ipaddr
assert ('fdff:ffff:ffff:ffc0::1', 64) in veth.ipaddr
assert veth.flags & 1
assert veth.mtu == mtu
assert veth.txqlen == txqlen
def create_interfaces(self):
# dummy interface
if_dummy = uifname()
if_vlan_stag = uifname()
if_vlan_ctag = uifname()
if_bridge = uifname()
if_port = uifname()
ret = []
with self.nl_class(**self.nl_kwarg) as ipr:
ipr.link('add',
ifname=if_dummy,
kind='dummy')
ret.append(self.link_wait(if_dummy))
ipr.link('add',
ifname=if_vlan_stag,
link=ret[-1],
vlan_id=101,
vlan_protocol=0x88a8,
kind='vlan')
ret.append(self.link_wait(if_vlan_stag))
ipr.link('add',
ifname=if_vlan_ctag,
link=ret[-1],
vlan_id=1001,
vlan_protocol=0x8100,
kind='vlan')
ret.append(self.link_wait(if_vlan_ctag))
ipr.link('add',
ifname=if_port,
kind='dummy')
ret.append(self.link_wait(if_port))
ipr.link('add',
ifname=if_bridge,
kind='bridge')
ret.append(self.link_wait(if_bridge))
ipr.link('set', index=ret[-2], master=ret[-1])
return ret
def test_veth_simple(self):
ifname = uifname()
peername = uifname()
(self.ndb.interfaces.create(ifname=ifname, peer=peername,
kind='veth').commit())
iflink = self.ndb.interfaces[ifname]['link']
plink = self.ndb.interfaces[peername]['link']
assert iflink == self.ndb.interfaces[peername]['index']
assert plink == self.ndb.interfaces[ifname]['index']
assert grep('%s ip link show' % self.ssh, pattern=ifname)
assert grep('%s ip link show' % self.ssh, pattern=peername)
(self.ndb.interfaces[ifname].remove().commit())
assert not grep('%s ip link show' % self.ssh, pattern=ifname)
assert not grep('%s ip link show' % self.ssh, pattern=peername)
def test_fail(self):
ifname = uifname()
kind = uifname()
ifobj = (self
.ndb
.interfaces
.add(ifname=ifname, kind=kind))
save = dict(ifobj)
try:
ifobj.commit()
except NetlinkError as e:
assert e.code == 95 # Operation not supported
assert save == dict(ifobj)
assert ifobj.scope == 'invalid'
def create(self, kind='dummy'):
require_user('root')
name = uifname()
self.ip.link('add', ifname=name, kind=kind)
idx = None
while not idx:
idx = self.ip.link_lookup(ifname=name)
idx = idx[0]
self.ifaces.append(idx)
return (name, idx)
def create(self, kind='dummy'):
require_user('root')
name = uifname()
self.ip.link('add', ifname=name, kind=kind)
idx = None
while not idx:
idx = self.ip.link_lookup(ifname=name)
idx = idx[0]
self.ifaces.append(idx)
return (name, idx)
def test_rename_plus_ipv6(self):
require_user('root')
mtu = 1280 # mtu must be >= 1280 if you plan to use IPv6
txqlen = 2000
nsid = str(uuid4())
ipdb_main = IPDB()
ipdb_test = IPDB(nl=NetNS(nsid))
if1 = uifname()
if2 = uifname()
if3 = uifname()
# create
ipdb_main.create(kind='veth',
ifname=if1,
peer=if2,
mtu=mtu,
txqlen=txqlen).commit()
# move
with ipdb_main.interfaces[if2] as veth:
veth.net_ns_fd = nsid
# set it up
with ipdb_test.interfaces[if2] as veth:
veth.add_ip('fdb3:84e5:4ff4:55e4::1/64')
veth.add_ip('fdff:ffff:ffff:ffc0::1/64')
veth.mtu = mtu
veth.txqlen = txqlen
veth.up()
veth.ifname = if3
veth = ipdb_test.interfaces.get(if3, None)
ipdb_main.release()
ipdb_test.release()
netnsmod.remove(nsid)
# check everything
assert ('fdb3:84e5:4ff4:55e4::1', 64) in veth.ipaddr
assert ('fdff:ffff:ffff:ffc0::1', 64) in veth.ipaddr
assert veth.flags & 1
assert veth.mtu == mtu
assert veth.txqlen == txqlen
def test_create_tuntap(self):
require_user('root')
# actually this test checks the nlsocket plugin feedback
# in a pair of remote client/server
foo = str(uuid4())
tun = uifname()
tap = uifname()
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=tun, kind='tuntap', mode='tun').commit()
ip.create(ifname=tap, kind='tuntap', mode='tap').commit()
assert tun in ip.interfaces.keys()
assert tap in ip.interfaces.keys()
ip.interfaces[tun].remove().commit()
ip.interfaces[tap].remove().commit()
assert tun not in ip.interfaces.keys()
assert tap not in ip.interfaces.keys()
netnsmod.remove(foo)
def ifname(self):
'''
Register and return a new unique interface name to
be used in a test.
'''
ifname = uifname()
self.ifnames.append(ifname)
self.rtm_events[ifname] = threading.Event()
self.rtm_newlink[ifname] = []
self.rtm_dellink[ifname] = []
return ifname
def interface_event():
with open(os.devnull, 'w') as fnull:
p0 = uifname()
add_command = 'ip link add dev %s type dummy' % p0
del_command = 'ip link del dev %s' % p0
subprocess.call(add_command.split(),
stdout=fnull,
stderr=fnull)
subprocess.call(del_command.split(),
stdout=fnull,
stderr=fnull)
def _ports_mtu_race(self, kind):
port1 = (self.ip
.create(ifname=uifname(), kind='dummy', mtu=1280)
.commit())
port2 = (self.ip
.create(ifname=uifname(), kind='dummy')
.commit())
master = (self.ip
.create(ifname=uifname(), kind=kind)
.commit())
try:
master.add_port(port1).commit()
master.add_port(port2).commit()
except:
raise
finally:
port1.remove().commit()
port2.remove().commit()
master.remove().commit()
def ifname(self):
'''
Register and return a new unique interface name to
be used in a test.
'''
ifname = uifname()
self.ifnames.append(ifname)
self.rtm_events[ifname] = threading.Event()
self.rtm_newlink[ifname] = []
self.rtm_dellink[ifname] = []
return ifname
def register(self, ifname=None, netns=None):
'''
Register an interface in `self.interfaces`. If no interface
name specified, create a random one.
All the saved interfaces will be removed on `teardown()`
'''
if ifname is None:
ifname = uifname()
self.interfaces[ifname] = netns
return ifname
def test_view_constraints_cmanager(self):
ifname = uifname()
ifaddr = self.ifaddr()
with self.ndb.interfaces as view:
view.constraints['target'] = self.netns
with view.create(ifname=ifname, kind='dummy') as interface:
interface['address'] = '00:11:22:33:44:55'
interface['state'] = 'up'
with interface.ipaddr as aview:
with aview.create(address=ifaddr, prefixlen=24):
pass
self._assert_test_view(ifname, ifaddr)
def test_create_tuntap(self):
# on CentOS 6.5 this test causes kernel panic
if platform.linux_distribution()[:2] == ('CentOS', '6.5'):
raise SkipTest('to avoid possible kernel panic')
# actually this test checks the nlsocket plugin feedback
# in a pair of remote client/server
foo = str(uuid4())
tun = uifname()
tap = uifname()
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=tun, kind='tuntap', mode='tun').commit()
ip.create(ifname=tap, kind='tuntap', mode='tap').commit()
assert tun in ip.interfaces.keys()
assert tap in ip.interfaces.keys()
ip.interfaces[tun].remove().commit()
ip.interfaces[tap].remove().commit()
assert tun not in ip.interfaces.keys()
assert tap not in ip.interfaces.keys()
netnsmod.remove(foo)
def test_create_tuntap(self):
# on CentOS 6.5 this test causes kernel panic
if platform.linux_distribution()[:2] == ('CentOS', '6.5'):
raise SkipTest('to avoid possible kernel panic')
# actually this test checks the nlsocket plugin feedback
# in a pair of remote client/server
foo = str(uuid4())
tun = uifname()
tap = uifname()
with IPDB(nl=NetNS(foo)) as ip:
ip.create(ifname=tun, kind='tuntap', mode='tun').commit()
ip.create(ifname=tap, kind='tuntap', mode='tap').commit()
assert tun in ip.interfaces.keys()
assert tap in ip.interfaces.keys()
ip.interfaces[tun].remove().commit()
ip.interfaces[tap].remove().commit()
assert tun not in ip.interfaces.keys()
assert tap not in ip.interfaces.keys()
netnsmod.remove(foo)
def test_bridge_fd_leaks(self):
ifs = []
for _ in range(RESPAWNS):
ifs.append(uifname())
with IPDB() as ipdb:
for name in ifs:
ipdb.create(ifname=name, kind="bridge").commit()
with IPDB() as ipdb:
for name in ifs:
ipdb.interfaces[name].remove().commit()
def test_view_constraints_pipeline(self):
ifname = uifname()
ifaddr = self.ifaddr()
(self
.ndb
.interfaces
.constraint('target', self.netns)
.create(ifname=ifname, kind='dummy')
.set('address', '00:11:22:33:44:55')
.set('state', 'up')
.ipaddr
.create(address=ifaddr, prefixlen=24)
.commit())
self._assert_test_view(ifname, ifaddr)
def test_tuntap_fd_leaks(self):
require_user('root')
ifs = []
for _ in range(RESPAWNS):
ifs.append(uifname())
with IPRoute() as ipr:
for name in ifs:
ipr.link("add", ifname=name, kind="tuntap", mode="tun")
with IPDB() as ipdb:
for name in ifs:
ipdb.interfaces[name].remove().commit()
def test_dummy0_loaded(object):
require_user("root")
# assert the module is loaded
ifA = uifname()
ip = IPDB()
ip.create(ifname=ifA, kind="dummy").commit()
try:
# try to create and fail in create()
ip.create(ifname="dummy0", kind="dummy")
except CreateException:
pass
except Exception:
raise
finally:
ip.interfaces[ifA].remove().commit()
ip.release()
def test_simple_deps(self):
with self.nl_class(**self.nl_kwarg) as ipr:
self.interfaces = []
#
# simple dummy interface with one address and
# one dependent route
#
self.if_simple = uifname()
ipr.link('add',
ifname=self.if_simple,
kind='dummy')
self.interfaces.append(self.link_wait(self.if_simple))
ipr.link('set',
index=self.interfaces[-1],
state='up')
ipr.addr('add',
index=self.interfaces[-1],
address='172.16.172.16',
prefixlen=24)
ipr.route('add',
dst='172.16.127.0',
dst_len=24,
gateway='172.16.172.17')
iface = self.ndb.interfaces[self.if_simple]
# check everything is in place
assert grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh,
pattern='172.16.127.*172.16.172.17')
# remove the interface
iface.remove()
iface.commit()
# check there is no interface, no route
assert not grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert not grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert not grep('%s ip route show' % self.ssh,
pattern='172.16.127.*172.16.172.17')
# revert the changes using the implicit last_save
iface.rollback()
assert grep('%s ip link show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh, pattern=self.if_simple)
assert grep('%s ip route show' % self.ssh,
pattern='172.16.127.*172.16.172.17')
