return f
-def setUpModule():
+def expectedFailureIf_ip6gre_do_not_support_ipv6ll():
+ def f(func):
+ rc = subprocess.call(['ip', 'link', 'add', 'name', 'test1', 'type', 'dummy'])
+ if rc != 0:
+ return unittest.expectedFailure(func)
+
+ time.sleep(1)
+ rc = subprocess.call(['ip', 'tunnel', 'add', 'tun99', 'local', '2a00:ffde:4567:edde::4986', 'remote', '2001:473:fece:cafe::5178', 'mode', 'ip6gre', 'dev', 'dummy99'])
+ if rc != 0:
+ return unittest.expectedFailure(func)
+
+ time.sleep(1)
+ # Not sure why, but '0' or '2' do not work.
+ rc = subprocess.call(['sysctl', '-w', 'net.ipv6.conf.tun99.addr_gen_mode=3'])
+ if rc != 0:
+ return unittest.expectedFailure(func)
+
+ time.sleep(1)
+ rc = subprocess.run(['ip', '-6', 'address', 'show', 'dev', 'tun99', 'scope', 'link'], stdout=subprocess.PIPE)
+ if rc.returncode != 0:
+ return unittest.expectedFailure(func)
+
+ if 'inet6' not in rc.stdout.rstrip().decode('utf-8'):
+ return unittest.expectedFailure(func)
+
+ return func
+
+ return f
+def setUpModule():
os.makedirs(network_unit_file_path, exist_ok=True)
os.makedirs(networkd_ci_path, exist_ok=True)
if (os.path.exists(os.path.join(network_unit_file_path, unit + '.d'))):
shutil.rmtree(os.path.join(network_unit_file_path, unit + '.d'))
- def start_dnsmasq(self, additional_options=''):
- dnsmasq_command = 'dnsmasq -8 /var/run/networkd-ci/test-dnsmasq-log-file --log-queries=extra --log-dhcp --pid-file=/var/run/networkd-ci/test-test-dnsmasq.pid --conf-file=/dev/null --interface=veth-peer --enable-ra --dhcp-range=2600::10,2600::20 --dhcp-range=192.168.5.10,192.168.5.200 -R --dhcp-leasefile=/var/run/networkd-ci/lease --dhcp-option=26,1492 --dhcp-option=option:router,192.168.5.1 --dhcp-option=33,192.168.5.4,192.168.5.5 --port=0 ' + additional_options
+ def start_dnsmasq(self, additional_options='', lease_time='1h'):
+ dnsmasq_command = f'dnsmasq -8 /var/run/networkd-ci/test-dnsmasq-log-file --log-queries=extra --log-dhcp --pid-file=/var/run/networkd-ci/test-test-dnsmasq.pid --conf-file=/dev/null --interface=veth-peer --enable-ra --dhcp-range=2600::10,2600::20,{lease_time} --dhcp-range=192.168.5.10,192.168.5.200,{lease_time} -R --dhcp-leasefile=/var/run/networkd-ci/lease --dhcp-option=26,1492 --dhcp-option=option:router,192.168.5.1 --dhcp-option=33,192.168.5.4,192.168.5.5 --port=0 ' + additional_options
subprocess.check_call(dnsmasq_command, shell=True)
time.sleep(10)
if sleep_sec > 0:
time.sleep(sleep_sec)
- def wait_online(self, links_with_operstate, timeout='20s'):
- args = [wait_online_bin, f' --timeout={timeout}'] + [f'--interface={link}' for link in links_with_operstate]
+ def wait_online(self, links_with_operstate, timeout='20s', bool_any=False):
+ args = [wait_online_bin, f'--timeout={timeout}'] + [f'--interface={link}' for link in links_with_operstate]
+ if bool_any:
+ args += ['--any']
subprocess.check_call(args)
class NetworkdNetDevTests(unittest.TestCase, Utilities):
'erspan98',
'erspan99',
'geneve99',
+ 'gretap96',
'gretap98',
'gretap99',
+ 'gretun96',
'gretun97',
'gretun98',
'gretun99',
'ip6tnl97',
'ip6tnl98',
'ip6tnl99',
+ 'ipiptun96',
'ipiptun97',
'ipiptun98',
'ipiptun99',
'ipvlan99',
+ 'ipvtap99',
'isataptun99',
'macvlan99',
'macvtap99',
+ 'sittun96',
'sittun97',
'sittun98',
'sittun99',
units = [
'10-dropin-test.netdev',
'11-dummy.netdev',
+ '11-dummy.network',
'12-dummy.netdev',
'15-name-conflict-test.netdev',
'21-macvlan.netdev',
'25-bond.netdev',
'25-bond-balanced-tlb.netdev',
'25-bridge.netdev',
+ '25-bridge.network',
'25-erspan-tunnel-local-any.netdev',
'25-erspan-tunnel.netdev',
+ '25-fou-gretap.netdev',
+ '25-fou-gre.netdev',
+ '25-fou-ipip.netdev',
+ '25-fou-ipproto-gre.netdev',
+ '25-fou-ipproto-ipip.netdev',
+ '25-fou-sit.netdev',
'25-geneve.netdev',
'25-gretap-tunnel-local-any.netdev',
'25-gretap-tunnel.netdev',
'25-ipip-tunnel-remote-any.netdev',
'25-ipip-tunnel.netdev',
'25-ipvlan.netdev',
+ '25-ipvtap.netdev',
'25-isatap-tunnel.netdev',
+ '25-macsec.key',
+ '25-macsec.netdev',
+ '25-macsec.network',
'25-sit-tunnel-local-any.netdev',
'25-sit-tunnel-remote-any.netdev',
'25-sit-tunnel.netdev',
'25-tap.netdev',
'25-tun.netdev',
+ '25-tunnel-local-any.network',
+ '25-tunnel-remote-any.network',
+ '25-tunnel.network',
'25-vcan.netdev',
'25-veth.netdev',
'25-vrf.netdev',
'25-vxlan.netdev',
'25-wireguard-23-peers.netdev',
'25-wireguard-23-peers.network',
+ '25-wireguard-preshared-key.txt',
'25-wireguard-private-key.txt',
'25-wireguard.netdev',
'25-wireguard.network',
'ip6tnl.network',
'ipip.network',
'ipvlan.network',
+ 'ipvtap.network',
'isatap.network',
+ 'macsec.network',
'macvlan.network',
'macvtap.network',
'sit.network',
'vti6.network',
'vti.network',
+ 'vxlan-test1.network',
'vxlan.network']
def setUp(self):
else:
print('ethtool does not support driver field at least for dummy interfaces, skipping test for Driver field of networkctl.')
+ def test_wait_online_any(self):
+ self.copy_unit_to_networkd_unit_path('25-bridge.netdev', '25-bridge.network', '11-dummy.netdev', '11-dummy.network')
+ self.start_networkd(0)
+
+ self.wait_online(['bridge99', 'test1:degraded'], bool_any=True)
+ self.assertTrue(self.link_exits('bridge99'))
+ self.assertTrue(self.link_exits('test1'))
+
+ output = subprocess.check_output(['networkctl', 'status', 'bridge99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'State: (?:off|no-carrier) \(configuring\)')
+
+ output = subprocess.check_output(['networkctl', 'status', 'test1']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'State: degraded \(configured\)')
+
def test_bridge(self):
self.copy_unit_to_networkd_unit_path('25-bridge.netdev')
self.start_networkd()
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'test1']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2004 ')
+ self.assertRegex(output, ' mtu 2000 ')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vlan99']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2000 ')
- self.assertTrue(output, 'REORDER_HDR')
- self.assertTrue(output, 'LOOSE_BINDING')
- self.assertTrue(output, 'GVRP')
- self.assertTrue(output, 'MVRP')
- self.assertTrue(output, ' id 99 ')
+ self.assertRegex(output, ' mtu 2000 ')
+ self.assertRegex(output, 'REORDER_HDR')
+ self.assertRegex(output, 'LOOSE_BINDING')
+ self.assertRegex(output, 'GVRP')
+ self.assertRegex(output, 'MVRP')
+ self.assertRegex(output, ' id 99 ')
output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'test1']).rstrip().decode('utf-8')
print(output)
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'test1']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2000 ')
+ self.assertRegex(output, ' mtu 2000 ')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'macvlan99']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2000 ')
+ self.assertRegex(output, ' mtu 2000 ')
@expectedFailureIfModuleIsNotAvailable('ipvlan')
def test_ipvlan(self):
self.assertTrue(self.link_exits('ipvlan99'))
+ @expectedFailureIfModuleIsNotAvailable('ipvtap')
+ def test_ipvtap(self):
+ self.copy_unit_to_networkd_unit_path('25-ipvtap.netdev', '11-dummy.netdev', 'ipvtap.network')
+ self.start_networkd()
+
+ self.assertTrue(self.link_exits('ipvtap99'))
+
def test_veth(self):
self.copy_unit_to_networkd_unit_path('25-veth.netdev')
self.start_networkd()
def test_wireguard(self):
self.copy_unit_to_networkd_unit_path('25-wireguard.netdev', '25-wireguard.network',
'25-wireguard-23-peers.netdev', '25-wireguard-23-peers.network',
- '25-wireguard-private-key.txt')
+ '25-wireguard-preshared-key.txt', '25-wireguard-private-key.txt')
self.start_networkd(0)
self.wait_online(['wg99:carrier', 'wg98:routable'])
subprocess.call('wg')
output = subprocess.check_output(['wg', 'show', 'wg99', 'listen-port']).rstrip().decode('utf-8')
- self.assertTrue(output, '51820')
+ self.assertRegex(output, '51820')
output = subprocess.check_output(['wg', 'show', 'wg99', 'fwmark']).rstrip().decode('utf-8')
- self.assertTrue(output, '0x4d2')
+ self.assertRegex(output, '0x4d2')
output = subprocess.check_output(['wg', 'show', 'wg99', 'allowed-ips']).rstrip().decode('utf-8')
- self.assertTrue(output, 'RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t192.168.26.0/24 fd31:bf08:57cb::/48')
- self.assertTrue(output, 'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\tfdbc:bae2:7871:e1fe:793:8636::/96 fdbc:bae2:7871:500:e1fe:793:8636:dad1/128')
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.26.0/24 fd31:bf08:57cb::/48')
+ self.assertRegex(output, 'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\tfdbc:bae2:7871:e1fe:793:8636::/96 fdbc:bae2:7871:500:e1fe:793:8636:dad1/128')
output = subprocess.check_output(['wg', 'show', 'wg99', 'persistent-keepalive']).rstrip().decode('utf-8')
- self.assertTrue(output, 'RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t20')
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t20')
output = subprocess.check_output(['wg', 'show', 'wg99', 'endpoints']).rstrip().decode('utf-8')
- self.assertTrue(output, 'RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t192.168.27.3:51820')
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.27.3:51820')
output = subprocess.check_output(['wg', 'show', 'wg99', 'private-key']).rstrip().decode('utf-8')
- self.assertTrue(output, 'EEGlnEPYJV//kbvvIqxKkQwOiS+UENyPncC4bF46ong=')
+ self.assertRegex(output, 'EEGlnEPYJV//kbvvIqxKkQwOiS\+UENyPncC4bF46ong=')
+ output = subprocess.check_output(['wg', 'show', 'wg99', 'preshared-keys']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA= IIWIV17wutHv7t4cR6pOT91z6NSz/T8Arh0yaywhw3M=')
+ self.assertRegex(output, 'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc= cPLOy1YUrEI0EMMIycPJmOo0aTu3RZnw8bL5meVD6m0=')
output = subprocess.check_output(['wg', 'show', 'wg98', 'private-key']).rstrip().decode('utf-8')
- self.assertTrue(output, 'CJQUtcS9emY2fLYqDlpSZiE/QJyHkPWr+WHtZLZ90FU=')
+ self.assertRegex(output, 'CJQUtcS9emY2fLYqDlpSZiE/QJyHkPWr\+WHtZLZ90FU=')
def test_geneve(self):
self.copy_unit_to_networkd_unit_path('25-geneve.netdev')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'geneve99']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, '192.168.22.1')
- self.assertTrue(output, '6082')
- self.assertTrue(output, 'udpcsum')
- self.assertTrue(output, 'udp6zerocsumrx')
+ self.assertRegex(output, '192.168.22.1')
+ self.assertRegex(output, '6082')
+ self.assertRegex(output, 'udpcsum')
+ self.assertRegex(output, 'udp6zerocsumrx')
def test_ipip_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ipip-tunnel.netdev', 'ipip.network',
- '25-ipip-tunnel-local-any.netdev', '25-ipip-tunnel-remote-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('ipiptun99'))
- self.assertTrue(self.link_exits('ipiptun98'))
- self.assertTrue(self.link_exits('ipiptun97'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ipip.network',
+ '25-ipip-tunnel.netdev', '25-tunnel.network',
+ '25-ipip-tunnel-local-any.netdev', '25-tunnel-local-any.network',
+ '25-ipip-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
+ self.start_networkd(0)
+ self.wait_online(['ipiptun99:routable', 'ipiptun98:routable', 'ipiptun97:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ipiptun99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'ipip (?:ipip |)remote any local 192.168.223.238 dev dummy98')
def test_gre_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-gre-tunnel.netdev', 'gretun.network',
- '25-gre-tunnel-local-any.netdev', '25-gre-tunnel-remote-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('gretun99'))
- self.assertTrue(self.link_exits('gretun98'))
- self.assertTrue(self.link_exits('gretun97'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'gretun.network',
+ '25-gre-tunnel.netdev', '25-tunnel.network',
+ '25-gre-tunnel-local-any.netdev', '25-tunnel-local-any.network',
+ '25-gre-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
+ self.start_networkd(0)
+ self.wait_online(['gretun99:routable', 'gretun98:routable', 'gretun97:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'gre remote 10.65.223.239 local 10.65.223.238 dev dummy98')
+ self.assertRegex(output, 'ikey 1.2.3.103')
+ self.assertRegex(output, 'okey 1.2.4.103')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun98']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'gre remote 10.65.223.239 local any dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.104')
+ self.assertRegex(output, 'okey 0.0.0.104')
+ self.assertNotRegex(output, 'iseq')
+ self.assertNotRegex(output, 'oseq')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun97']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'gre remote any local 10.65.223.238 dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.105')
+ self.assertRegex(output, 'okey 0.0.0.105')
+ self.assertNotRegex(output, 'iseq')
+ self.assertNotRegex(output, 'oseq')
+ @expectedFailureIf_ip6gre_do_not_support_ipv6ll()
def test_ip6gre_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6gre-tunnel.netdev', 'ip6gretun.network',
- '25-ip6gre-tunnel-local-any.netdev', '25-ip6gre-tunnel-remote-any.netdev')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6gretun.network',
+ '25-ip6gre-tunnel.netdev', '25-tunnel.network',
+ '25-ip6gre-tunnel-local-any.netdev', '25-tunnel-local-any.network',
+ '25-ip6gre-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
print(output)
self.assertRegex(output, 'ip6gre remote any local 2a00:ffde:4567:edde::4987 dev dummy98')
- def test_gretap_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-gretap-tunnel.netdev', 'gretap.network',
- '25-gretap-tunnel-local-any.netdev')
- self.start_networkd()
+ # Old kernels may not support IPv6LL address on ip6gre tunnel, and the following test may fails.
+ self.wait_online(['ip6gretun99:routable', 'ip6gretun98:routable', 'ip6gretun97:routable', 'dummy98:degraded'])
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('gretap99'))
- self.assertTrue(self.link_exits('gretap98'))
+ def test_gretap_tunnel(self):
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'gretap.network',
+ '25-gretap-tunnel.netdev', '25-tunnel.network',
+ '25-gretap-tunnel-local-any.netdev', '25-tunnel-local-any.network')
+ self.start_networkd(0)
+ self.wait_online(['gretap99:routable', 'gretap98:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretap99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'gretap remote 10.65.223.239 local 10.65.223.238 dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.106')
+ self.assertRegex(output, 'okey 0.0.0.106')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretap98']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'gretap remote 10.65.223.239 local any dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.107')
+ self.assertRegex(output, 'okey 0.0.0.107')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
def test_ip6gretap_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6gretap-tunnel.netdev', 'ip6gretap.network',
- '25-ip6gretap-tunnel-local-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('ip6gretap99'))
- self.assertTrue(self.link_exits('ip6gretap98'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6gretap.network',
+ '25-ip6gretap-tunnel.netdev', '25-tunnel.network',
+ '25-ip6gretap-tunnel-local-any.netdev', '25-tunnel-local-any.network')
+ self.start_networkd(0)
+ self.wait_online(['ip6gretap99:routable', 'ip6gretap98:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6gretap99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'ip6gretap remote 2001:473:fece:cafe::5179 local any dev dummy98')
def test_vti_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-vti-tunnel.netdev', 'vti.network',
- '25-vti-tunnel-local-any.netdev', '25-vti-tunnel-remote-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('vtitun99'))
- self.assertTrue(self.link_exits('vtitun98'))
- self.assertTrue(self.link_exits('vtitun97'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'vti.network',
+ '25-vti-tunnel.netdev', '25-tunnel.network',
+ '25-vti-tunnel-local-any.netdev', '25-tunnel-local-any.network',
+ '25-vti-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
+ self.start_networkd(0)
+ self.wait_online(['vtitun99:routable', 'vtitun98:routable', 'vtitun97:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vtitun99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'vti remote any local 10.65.223.238 dev dummy98')
def test_vti6_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-vti6-tunnel.netdev', 'vti6.network',
- '25-vti6-tunnel-local-any.netdev', '25-vti6-tunnel-remote-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('vti6tun99'))
- self.assertTrue(self.link_exits('vti6tun98'))
- self.assertTrue(self.link_exits('vti6tun97'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'vti6.network',
+ '25-vti6-tunnel.netdev', '25-tunnel.network',
+ '25-vti6-tunnel-local-any.netdev', '25-tunnel-local-any.network',
+ '25-vti6-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
+ self.start_networkd(0)
+ self.wait_online(['vti6tun99:routable', 'vti6tun98:routable', 'vti6tun97:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vti6tun99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'vti6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
def test_ip6tnl_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6tnl-tunnel.netdev', 'ip6tnl.network',
- '25-ip6tnl-tunnel-local-any.netdev', '25-ip6tnl-tunnel-remote-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('ip6tnl99'))
- self.assertTrue(self.link_exits('ip6tnl98'))
- self.assertTrue(self.link_exits('ip6tnl97'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6tnl.network',
+ '25-ip6tnl-tunnel.netdev', '25-tunnel.network',
+ '25-ip6tnl-tunnel-local-any.netdev', '25-tunnel-local-any.network',
+ '25-ip6tnl-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
+ self.start_networkd(0)
+ self.wait_online(['ip6tnl99:routable', 'ip6tnl98:routable', 'ip6tnl97:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6tnl99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'ip6tnl ip6ip6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
def test_sit_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-sit-tunnel.netdev', 'sit.network',
- '25-sit-tunnel-local-any.netdev',
- '25-sit-tunnel-remote-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('sittun99'))
- self.assertTrue(self.link_exits('sittun98'))
- self.assertTrue(self.link_exits('sittun97'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'sit.network',
+ '25-sit-tunnel.netdev', '25-tunnel.network',
+ '25-sit-tunnel-local-any.netdev', '25-tunnel-local-any.network',
+ '25-sit-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
+ self.start_networkd(0)
+ self.wait_online(['sittun99:routable', 'sittun98:routable', 'sittun97:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, "sit (?:ip6ip |)remote any local 10.65.223.238 dev dummy98")
def test_isatap_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-isatap-tunnel.netdev', 'isatap.network')
- self.start_networkd()
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'isatap.network',
+ '25-isatap-tunnel.netdev', '25-tunnel.network')
+ self.start_networkd(0)
+ self.wait_online(['isataptun99:routable', 'dummy98:degraded'])
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('isataptun99'))
self.assertRegex(output, "isatap ")
def test_6rd_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-6rd-tunnel.netdev', '6rd.network')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('sittun99'))
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '6rd.network',
+ '25-6rd-tunnel.netdev', '25-tunnel.network')
+ self.start_networkd(0)
+ self.wait_online(['sittun99:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun99']).rstrip().decode('utf-8')
print(output)
@expectedFailureIfERSPANModuleIsNotAvailable()
def test_erspan_tunnel(self):
self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'erspan.network',
- '25-erspan-tunnel.netdev', '25-erspan-tunnel-local-any.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('erspan99'))
- self.assertTrue(self.link_exits('erspan98'))
+ '25-erspan-tunnel.netdev', '25-tunnel.network',
+ '25-erspan-tunnel-local-any.netdev', '25-tunnel-local-any.network')
+ self.start_networkd(0)
+ self.wait_online(['erspan99:routable', 'erspan98:routable', 'dummy98:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'erspan99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'erspan remote 172.16.1.100 local 172.16.1.200')
- self.assertRegex(output, '101')
+ self.assertRegex(output, 'ikey 0.0.0.101')
+ self.assertRegex(output, 'okey 0.0.0.101')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'erspan98']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'erspan remote 172.16.1.100 local any')
self.assertRegex(output, '102')
+ self.assertRegex(output, 'ikey 0.0.0.102')
+ self.assertRegex(output, 'okey 0.0.0.102')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
def test_tunnel_independent(self):
self.copy_unit_to_networkd_unit_path('25-ipip-tunnel-independent.netdev')
self.assertTrue(self.link_exits('ipiptun99'))
- def test_vxlan(self):
- self.copy_unit_to_networkd_unit_path('25-vxlan.netdev', 'vxlan.network', '11-dummy.netdev')
+ @expectedFailureIfModuleIsNotAvailable('fou')
+ def test_fou(self):
+ # The following redundant check is necessary for CentOS CI.
+ # Maybe, error handling in lookup_id() in sd-netlink/generic-netlink.c needs to be updated.
+ self.assertTrue(is_module_available('fou'))
+
+ self.copy_unit_to_networkd_unit_path('25-fou-ipproto-ipip.netdev', '25-fou-ipproto-gre.netdev',
+ '25-fou-ipip.netdev', '25-fou-sit.netdev',
+ '25-fou-gre.netdev', '25-fou-gretap.netdev')
self.start_networkd()
- self.assertTrue(self.link_exits('vxlan99'))
+ self.assertTrue(self.link_exits('ipiptun96'))
+ self.assertTrue(self.link_exits('sittun96'))
+ self.assertTrue(self.link_exits('gretun96'))
+ self.assertTrue(self.link_exits('gretap96'))
+
+ output = subprocess.check_output(['ip', 'fou', 'show']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'port 55555 ipproto 4')
+ self.assertRegex(output, 'port 55556 ipproto 47')
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ipiptun96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport 1001 encap-dport 55556')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretap96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55556')
+
+ subprocess.call(['ip', 'fou', 'del', 'port', '55555'])
+ subprocess.call(['ip', 'fou', 'del', 'port', '55556'])
+
+ def test_vxlan(self):
+ self.copy_unit_to_networkd_unit_path('25-vxlan.netdev', 'vxlan.network',
+ '11-dummy.netdev', 'vxlan-test1.network')
+ self.start_networkd(0)
+
+ self.wait_online(['test1:degraded', 'vxlan99:degraded'])
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vxlan99']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, "999")
+ self.assertRegex(output, '999')
self.assertRegex(output, '5555')
self.assertRegex(output, 'l2miss')
self.assertRegex(output, 'l3miss')
self.assertRegex(output, 'remcsumrx')
self.assertRegex(output, 'gbp')
+ output = subprocess.check_output(['bridge', 'fdb', 'show', 'dev', 'vxlan99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, '00:11:22:33:44:55 dst 10.0.0.5 self permanent')
+ self.assertRegex(output, '00:11:22:33:44:66 dst 10.0.0.6 self permanent')
+ self.assertRegex(output, '00:11:22:33:44:77 dst 10.0.0.7 self permanent')
+
+ def test_macsec(self):
+ self.copy_unit_to_networkd_unit_path('25-macsec.netdev', '25-macsec.network', '25-macsec.key',
+ 'macsec.network', '12-dummy.netdev')
+ self.start_networkd(0)
+
+ self.wait_online(['dummy98:degraded', 'macsec99:routable'])
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'macsec99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'macsec99@dummy98')
+ self.assertRegex(output, 'macsec sci [0-9a-f]*000b')
+ self.assertRegex(output, 'encrypt on')
+
+ output = subprocess.check_output(['ip', 'macsec', 'show', 'macsec99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encrypt on')
+ self.assertRegex(output, 'TXSC: [0-9a-f]*000b on SA 1')
+ self.assertRegex(output, '0: PN [0-9]*, state on, key 01000000000000000000000000000000')
+ self.assertRegex(output, '1: PN [0-9]*, state on, key 02030000000000000000000000000000')
+ self.assertRegex(output, 'RXSC: c619528fe6a00100, state on')
+ self.assertRegex(output, '0: PN [0-9]*, state on, key 02030405000000000000000000000000')
+ self.assertRegex(output, '1: PN [0-9]*, state on, key 02030405060000000000000000000000')
+ self.assertRegex(output, '2: PN [0-9]*, state off, key 02030405060700000000000000000000')
+ self.assertRegex(output, '3: PN [0-9]*, state off, key 02030405060708000000000000000000')
+ self.assertNotRegex(output, 'key 02030405067080900000000000000000')
+ self.assertRegex(output, 'RXSC: 8c16456c83a90002, state on')
+ self.assertRegex(output, '0: PN [0-9]*, state off, key 02030400000000000000000000000000')
+
+
class NetworkdL2TPTests(unittest.TestCase, Utilities):
links =[
print(output)
self.assertRegex(output, '149.10.124.48/28 proto kernel scope link src 149.10.124.58')
self.assertRegex(output, '149.10.124.64 proto static scope link')
+ self.assertRegex(output, '169.254.0.0/16 proto static scope link metric 2048')
self.assertRegex(output, '192.168.1.1 proto static initcwnd 20')
self.assertRegex(output, '192.168.1.2 proto static initrwnd 30')
output = subprocess.check_output(['ip', '-4', 'route', 'show', 'dev', 'dummy98', 'default']).rstrip().decode('utf-8')
self.assertRegex(output, 'default via 149.10.125.65 proto static onlink')
self.assertRegex(output, 'default via 149.10.124.64 proto static')
+ self.assertRegex(output, 'default proto static')
output = subprocess.check_output(['ip', 'route', 'show', 'type', 'blackhole']).rstrip().decode('utf-8')
print(output)
'dhcp-client-route-metric.network',
'dhcp-client-route-table.network',
'dhcp-client-vrf.network',
+ 'dhcp-client-with-ipv4ll-fallback-with-dhcp-server.network',
+ 'dhcp-client-with-ipv4ll-fallback-without-dhcp-server.network',
'dhcp-client.network',
'dhcp-server-veth-peer.network',
'dhcp-v4-server-veth-peer.network',
def test_dhcp_client_ipv6_only(self):
self.copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-only.network')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('veth99'))
+ self.start_networkd(0)
+ self.wait_online(['veth-peer:carrier'])
self.start_dnsmasq()
+ self.wait_online(['veth99:routable', 'veth-peer:routable'])
output = subprocess.check_output(['networkctl', 'status', 'veth99']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, '2600::')
self.assertNotRegex(output, '192.168.5')
+ # Confirm that ipv6 token is not set in the kernel
+ output = subprocess.check_output(['ip', 'token', 'show', 'dev', 'veth99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'token :: dev veth99')
+
def test_dhcp_client_ipv4_only(self):
self.copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv4-only-ipv6-disabled.network')
self.start_networkd()
print(output)
self.assertRegex(output, '192.168.5.*')
- # Stoping dnsmasq as networkd won't be allowed to renew the DHCP lease.
+ # Stopping dnsmasq as networkd won't be allowed to renew the DHCP lease.
self.stop_dnsmasq(dnsmasq_pid_file)
# Sleep for 120 sec as the dnsmasq minimum lease time can only be set to 120
print(output)
self.assertRegex(output, 'onlink')
+ def test_dhcp_client_with_ipv4ll_fallback_with_dhcp_server(self):
+ self.copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
+ 'dhcp-client-with-ipv4ll-fallback-with-dhcp-server.network')
+ self.start_networkd(0)
+ self.wait_online(['veth-peer:carrier'])
+ self.start_dnsmasq(lease_time='2m')
+ self.wait_online(['veth99:routable', 'veth-peer:routable'])
+
+ output = subprocess.check_output(['ip', 'address', 'show', 'dev', 'veth99']).rstrip().decode('utf-8')
+ print(output)
+
+ output = subprocess.check_output(['ip', '-6', 'address', 'show', 'dev', 'veth99', 'scope', 'global', 'dynamic']).rstrip().decode('utf-8')
+ self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
+ output = subprocess.check_output(['ip', '-6', 'address', 'show', 'dev', 'veth99', 'scope', 'link']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet6 .* scope link')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'veth99', 'scope', 'global', 'dynamic']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'veth99', 'scope', 'link']).rstrip().decode('utf-8')
+ self.assertNotRegex(output, 'inet .* scope link')
+
+ print('Wait for the dynamic address to be expired')
+ time.sleep(130)
+
+ output = subprocess.check_output(['ip', 'address', 'show', 'dev', 'veth99']).rstrip().decode('utf-8')
+ print(output)
+
+ output = subprocess.check_output(['ip', '-6', 'address', 'show', 'dev', 'veth99', 'scope', 'global', 'dynamic']).rstrip().decode('utf-8')
+ self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
+ output = subprocess.check_output(['ip', '-6', 'address', 'show', 'dev', 'veth99', 'scope', 'link']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet6 .* scope link')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'veth99', 'scope', 'global', 'dynamic']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'veth99', 'scope', 'link']).rstrip().decode('utf-8')
+ self.assertNotRegex(output, 'inet .* scope link')
+
+ self.search_words_in_dnsmasq_log('DHCPOFFER', show_all=True)
+
+ def test_dhcp_client_with_ipv4ll_fallback_without_dhcp_server(self):
+ self.copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
+ 'dhcp-client-with-ipv4ll-fallback-without-dhcp-server.network')
+ self.start_networkd(0)
+ self.wait_online(['veth99:degraded', 'veth-peer:routable'])
+
+ output = subprocess.check_output(['ip', 'address', 'show', 'dev', 'veth99']).rstrip().decode('utf-8')
+ print(output)
+
+ output = subprocess.check_output(['ip', '-6', 'address', 'show', 'dev', 'veth99', 'scope', 'global', 'dynamic']).rstrip().decode('utf-8')
+ self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
+ output = subprocess.check_output(['ip', '-6', 'address', 'show', 'dev', 'veth99', 'scope', 'link']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet6 .* scope link')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'veth99', 'scope', 'global', 'dynamic']).rstrip().decode('utf-8')
+ self.assertNotRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'veth99', 'scope', 'link']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet .* scope link')
+
if __name__ == '__main__':
unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout,
verbosity=3))
projects / thirdparty / systemd.git / blobdiff