Пример #1
0
    def test_switch_change_bonded_network_with_dhclient(self):
        with veth_pair() as (server, nic1):
            with dummy_device() as nic2:
                NETSETUP_SOURCE = {
                    NET1_NAME: {
                        'bonding': BOND_NAME,
                        'bootproto': 'dhcp',
                        'blockingdhcp': True,
                        'switch': self.switch_type_source
                    }
                }
                NETSETUP_TARGET = _change_switch_type(NETSETUP_SOURCE,
                                                      self.switch_type_target)
                BONDSETUP_SOURCE = {
                    BOND_NAME: {
                        'nics': [nic1, nic2],
                        'switch': self.switch_type_source
                    }
                }
                BONDSETUP_TARGET = _change_switch_type(BONDSETUP_SOURCE,
                                                       self.switch_type_target)

                addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
                linkSet(server, ['up'])

                with dnsmasq_run(server, DHCPv4_RANGE_FROM, DHCPv4_RANGE_TO):
                    with self.setupNetworks(NETSETUP_SOURCE, BONDSETUP_SOURCE,
                                            NOCHK):
                        self.setupNetworks(NETSETUP_TARGET, BONDSETUP_TARGET,
                                           NOCHK)
                        self.assertNetwork(NET1_NAME,
                                           NETSETUP_TARGET[NET1_NAME])
                        self.assertBond(BOND_NAME, BONDSETUP_TARGET[BOND_NAME])
Пример #2
0
    def test_switch_change_bonded_network_with_dhclient(self):
        with veth_pair() as (server, nic1):
            with dummy_device() as nic2:
                NETSETUP_SOURCE = {NET1_NAME: {
                    'bonding': BOND_NAME,
                    'bootproto': 'dhcp',
                    'blockingdhcp': True,
                    'switch': self.switch_type_source}}
                NETSETUP_TARGET = _change_switch_type(
                    NETSETUP_SOURCE, self.switch_type_target)
                BONDSETUP_SOURCE = {BOND_NAME: {
                    'nics': [nic1, nic2], 'switch': self.switch_type_source}}
                BONDSETUP_TARGET = _change_switch_type(
                    BONDSETUP_SOURCE, self.switch_type_target)

                addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
                linkSet(server, ['up'])

                with dnsmasq_run(server, DHCPv4_RANGE_FROM, DHCPv4_RANGE_TO):
                    with self.setupNetworks(
                            NETSETUP_SOURCE, BONDSETUP_SOURCE, NOCHK):
                        self.setupNetworks(
                            NETSETUP_TARGET, BONDSETUP_TARGET, NOCHK)
                        self.assertNetwork(
                            NET1_NAME, NETSETUP_TARGET[NET1_NAME])
                        self.assertBond(BOND_NAME, BONDSETUP_TARGET[BOND_NAME])
Пример #3
0
    def test_local_auto_with_dynamic_address_from_ra(self):
        IPV6_NETADDRESS = '2001:1:1:1'
        IPV6_NETPREFIX_LEN = '64'
        with veth_pair() as (server, client):
            with dnsmasq_run(server, ipv6_slaac_prefix=IPV6_NETADDRESS + '::'):
                with wait_for_ipv6(client):
                    ipwrapper.linkSet(client, ['up'])
                    ipwrapper.linkSet(server, ['up'])
                    ipwrapper.addrAdd(server,
                                      IPV6_NETADDRESS + '::1',
                                      IPV6_NETPREFIX_LEN,
                                      family=6)

                # Expecting link and global addresses on client iface
                # The addresses are given randomly, so we sort them
                ip_addrs = sorted(addresses.getIpAddrs()[client],
                                  key=lambda ip: ip['address'])
                self.assertEqual(2, len(ip_addrs))

                self.assertTrue(addresses.is_dynamic(ip_addrs[0]))
                self.assertEqual('global', ip_addrs[0]['scope'])
                self.assertEqual(IPV6_NETADDRESS,
                                 ip_addrs[0]['address'][:len(IPV6_NETADDRESS)])

                self.assertEqual('link', ip_addrs[1]['scope'])
Пример #4
0
    def test_attach_dhcp_nic_to_ipless_network(self, switch):
        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            addrAdd(server, IPv6_ADDRESS, IPv6_CIDR, IpFamily.IPv6)
            linkSet(server, ['up'])
            with dnsmasq_run(server,
                             DHCPv4_RANGE_FROM,
                             DHCPv4_RANGE_TO,
                             DHCPv6_RANGE_FROM,
                             DHCPv6_RANGE_TO,
                             router=DHCPv4_GATEWAY):
                with dhclient_run(client):
                    adapter.assertDhclient(client, family=IpFamily.IPv4)
                    adapter.assertDhclient(client, family=IpFamily.IPv6)

                    NETCREATE = {
                        NETWORK_NAME: {
                            'nic': client,
                            'switch': switch
                        }
                    }
                    with adapter.setupNetworks(NETCREATE, {}, NOCHK):
                        nic_netinfo = adapter.netinfo.nics[client]
                        adapter.assertDisabledIPv4(nic_netinfo)
                        adapter.assertDisabledIPv6(nic_netinfo)
                        net_netinfo = adapter.netinfo.networks[NETWORK_NAME]
                        adapter.assertDisabledIPv4(net_netinfo)
                        adapter.assertDisabledIPv6(nic_netinfo)
Пример #5
0
    def test_add_net_with_dhcp(self, switch, families, bridged):

        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            addrAdd(server, IPv6_ADDRESS, IPv6_CIDR, IpFamily.IPv6)
            linkSet(server, ['up'])
            with dnsmasq_run(server, DHCPv4_RANGE_FROM, DHCPv4_RANGE_TO,
                             DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO,
                             router=DHCPv4_GATEWAY):

                network_attrs = {'bridged': bridged,
                                 'nic': client,
                                 'blockingdhcp': True,
                                 'switch': switch}

                if IpFamily.IPv4 in families:
                    network_attrs['bootproto'] = 'dhcp'
                if IpFamily.IPv6 in families:
                    network_attrs['dhcpv6'] = True

                netcreate = {NETWORK_NAME: network_attrs}

                with adapter.setupNetworks(netcreate, {}, NOCHK):
                    adapter.assertNetworkIp(
                        NETWORK_NAME, netcreate[NETWORK_NAME])
Пример #6
0
    def test_sourceroute_add_over_existing_route(self):
        with dummy_device() as nic:
            addrAdd(nic, IPV4_ADDRESS, IPV4_MASK)

            with create_sourceroute(device=nic, ip=IPV4_ADDRESS,
                                    mask=IPV4_MASK, gateway=IPV4_GW):
                sourceroute.add(nic, IPV4_ADDRESS, IPV4_MASK, IPV4_GW)
Пример #7
0
    def test_sourceroute_add_remove_and_read(self, nic0):
        addrAdd(nic0, IPV4_ADDRESS, IPV4_MASK)

        with create_sourceroute(device=nic0,
                                ip=IPV4_ADDRESS,
                                mask=IPV4_MASK,
                                gateway=IPV4_GW):
            dsroute = DynamicSourceRoute(nic0, None, None, None)
            routes, rules = dsroute.current_srconfig()

            assert len(routes) == 2
            assert len(rules) == 2

            assert routes[0].to == '0.0.0.0/0'
            assert routes[0].device == nic0
            assert routes[1].to == IPV4_NET
            assert routes[1].device == nic0

            assert rules[0].to == IPV4_NET
            assert rules[0].table == IPV4_TABLE
            assert rules[0].iif == nic0
            assert rules[0].prio == sourceroute.RULE_PRIORITY
            assert rules[1].src == IPV4_NET
            assert rules[1].table == IPV4_TABLE
            assert rules[1].prio == sourceroute.RULE_PRIORITY
Пример #8
0
    def test_ovirtmgmtm_to_ovs(self):
        """ Test transformation of initial management network to OVS.
        # TODO: test it with ovirtmgmt and test-network
        # NOTE: without default route
        # TODO: more asserts
        """
        with veth_pair() as (left, right):
            addrAdd(left, IP_ADDRESS, IP_CIDR)
            addrAdd(left, IPv6_ADDRESS, IPv6_CIDR, 6)
            linkSet(left, ['up'])
            with dnsmasq_run(left, DHCP_RANGE_FROM, DHCP_RANGE_TO,
                             DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO, IP_GATEWAY):
                network = {
                    NETWORK_NAME: {
                        'nic': right,
                        'bootproto': 'dhcp',
                        'bridged': True,
                        'blockingdhcp': True
                    }
                }
                options = NOCHK
                options['ovs'] = False

                try:
                    status, msg = self.setupNetworks(network, {}, options)
                    self.assertEqual(status, SUCCESS, msg)
                    self.assertNetworkExists(NETWORK_NAME)

                    options['ovs'] = True
                    status, msg = self.setupNetworks(network, {}, options)
                    self.assertEqual(status, SUCCESS, msg)
                    self.assertNetworkExists(NETWORK_NAME)
                finally:
                    dhcp.delete_dhclient_leases(NETWORK_NAME, True, False)
Пример #9
0
def _set_network_ip_config(ip_config):
    """Set IP configuration on Vdsm controlled OVS network"""
    iface = ip_config.top_dev
    ipv4 = ip_config.ipv4
    ipv6 = ip_config.ipv6
    port = ip_config.port
    blocking_dhcp = ip_config.blocking_dhcp

    net_dev = NetDevice(iface, iproute2, ipv4=ipv4, ipv6=ipv6,
                        blockingdhcp=blocking_dhcp)
    DynamicSourceRoute.addInterfaceTracking(net_dev)
    ipwrapper.linkSet(iface, ['down'])
    if ipv4.address:
        ipwrapper.addrAdd(iface, ipv4.address, ipv4.netmask)
    if ipv4.gateway and ipv4.defaultRoute:
        ipwrapper.routeAdd(['default', 'via', ipv4.gateway])
    if ipv6.address or ipv6.ipv6autoconf or ipv6.dhcpv6:
        sysctl.disable_ipv6(iface, disable=False)
    else:
        sysctl.disable_ipv6(iface)
    if ipv6.address:
        ipv6addr, ipv6netmask = ipv6.address.split('/')
        ipwrapper.addrAdd(iface, ipv6addr, ipv6netmask, family=6)
        if ipv6.gateway:
            ipwrapper.routeAdd(['default', 'via', ipv6.gateway], dev=iface,
                               family=6)
    ipwrapper.linkSet(port, ['up'])
    ipwrapper.linkSet(iface, ['up'])
    if ipv4.bootproto == 'dhcp':
        _run_dhclient(iface, blocking_dhcp, ipv4.defaultRoute, 4)
    if ipv6.dhcpv6:
        _run_dhclient(iface, blocking_dhcp, ipv6.defaultRoute, 6)
    iproute2._addSourceRoute(net_dev)
Пример #10
0
    def test_ovirtmgmtm_to_ovs(self):
        """ Test transformation of initial management network to OVS.
        # TODO: test it with ovirtmgmt and test-network
        # NOTE: without default route
        # TODO: more asserts
        """
        with veth_pair() as (left, right):
            addrAdd(left, IP_ADDRESS, IP_CIDR)
            addrAdd(left, IPv6_ADDRESS, IPv6_CIDR, 6)
            linkSet(left, ['up'])
            with dnsmasq_run(left, DHCP_RANGE_FROM, DHCP_RANGE_TO,
                             DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO, IP_GATEWAY):
                network = {
                    NETWORK_NAME: {'nic': right, 'bootproto': 'dhcp',
                                   'bridged': True, 'blockingdhcp': True}}
                options = NOCHK
                options['ovs'] = False

                try:
                    status, msg = self.setupNetworks(network, {}, options)
                    self.assertEqual(status, SUCCESS, msg)
                    self.assertNetworkExists(NETWORK_NAME)

                    options['ovs'] = True
                    status, msg = self.setupNetworks(network, {}, options)
                    self.assertEqual(status, SUCCESS, msg)
                    self.assertNetworkExists(NETWORK_NAME)
                finally:
                    dhcp.delete_dhclient_leases(NETWORK_NAME, True, False)
Пример #11
0
    def test_attach_dhcp_nic_to_dhcpv6_bridged_network(self, switch):
        if switch == 'ovs':
            pytest.xfail('IPv6 dynamic fails with OvS'
                         'see https://bugzilla.redhat.com/1773471')
        with veth_pair() as (server, client):
            addrAdd(server, IPv6_ADDRESS, IPv6_CIDR, IpFamily.IPv6)
            linkSet(server, ['up'])
            with dnsmasq_run(server, DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO):
                with dhcp_client_run(client, family=IpFamily.IPv6):
                    adapter.assertDhclient(client, family=IpFamily.IPv6)

                    NETCREATE = {
                        NETWORK_NAME: {
                            'nic': client,
                            'dhcpv6': True,
                            'blockingdhcp': True,
                            'switch': switch,
                        }
                    }
                    with adapter.setupNetworks(NETCREATE, {}, NOCHK):
                        nic_netinfo = adapter.netinfo.nics[client]
                        adapter.assertDisabledIPv6(nic_netinfo)
                        adapter.assertNoDhclient(client, family=IpFamily.IPv6)
                        net_netinfo = adapter.netinfo.networks[NETWORK_NAME]
                        adapter.assertDHCPv6(net_netinfo)
                        adapter.assertDhclient(NETWORK_NAME,
                                               family=IpFamily.IPv6)
Пример #12
0
 def test_local_auto_with_static_address_without_ra_server(self, nic0):
     ipwrapper.addrAdd(nic0, '2001::88', IPV6_PREFIX_LENGTH, family=6)
     ip_addrs = addresses.getIpAddrs()[nic0]
     assert addresses.is_ipv6_local_auto(nic0)
     assert 2 == len(ip_addrs), ip_addrs
     assert addresses.is_ipv6(ip_addrs[0])
     assert not addresses.is_dynamic(ip_addrs[0])
Пример #13
0
    def test_attach_dhcp_nic_to_dhcpv4_bridged_network(self, switch):
        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            linkSet(server, ['up'])
            with dnsmasq_run(server,
                             DHCPv4_RANGE_FROM,
                             DHCPv4_RANGE_TO,
                             router=DHCPv4_GATEWAY):
                with dhclient_run(client):
                    adapter.assertDhclient(client, family=IpFamily.IPv4)

                    NETCREATE = {
                        NETWORK_NAME: {
                            'nic': client,
                            'bootproto': 'dhcp',
                            'blockingdhcp': True,
                            'switch': switch
                        }
                    }
                    with adapter.setupNetworks(NETCREATE, {}, NOCHK):
                        nic_netinfo = adapter.netinfo.nics[client]
                        adapter.assertDisabledIPv4(nic_netinfo)
                        adapter.assertNoDhclient(client, family=IpFamily.IPv4)
                        net_netinfo = adapter.netinfo.networks[NETWORK_NAME]
                        adapter.assertDHCPv4(net_netinfo)
                        adapter.assertDhclient(NETWORK_NAME,
                                               family=IpFamily.IPv4)
Пример #14
0
    def test_add_net_with_dhcp(self, switch, families, bridged):

        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            addrAdd(server, IPv6_ADDRESS, IPv6_CIDR, IpFamily.IPv6)
            linkSet(server, ['up'])
            with dnsmasq_run(server,
                             DHCPv4_RANGE_FROM,
                             DHCPv4_RANGE_TO,
                             DHCPv6_RANGE_FROM,
                             DHCPv6_RANGE_TO,
                             router=DHCPv4_GATEWAY):

                network_attrs = {
                    'bridged': bridged,
                    'nic': client,
                    'blockingdhcp': True,
                    'switch': switch
                }

                if IpFamily.IPv4 in families:
                    network_attrs['bootproto'] = 'dhcp'
                if IpFamily.IPv6 in families:
                    network_attrs['dhcpv6'] = True

                netcreate = {NETWORK_NAME: network_attrs}

                with adapter.setupNetworks(netcreate, {}, NOCHK):
                    adapter.assertNetworkIp(NETWORK_NAME,
                                            netcreate[NETWORK_NAME])
Пример #15
0
    def test_sourceroute_add_remove_and_read(self):
        with dummy_device() as nic:
            addrAdd(nic, IPV4_ADDRESS, IPV4_MASK)

            with create_sourceroute(device=nic,
                                    ip=IPV4_ADDRESS,
                                    mask=IPV4_MASK,
                                    gateway=IPV4_GW):
                dsroute = DynamicSourceRoute(nic, None, None, None)
                routes, rules = dsroute.current_srconfig()

                self.assertEqual(2, len(routes), routes)
                self.assertEqual(2, len(rules), rules)

                self.assertEqual('0.0.0.0/0', routes[0].to)
                self.assertEqual(nic, routes[0].device)
                self.assertEqual(IPv4_NET, routes[1].to)
                self.assertEqual(nic, routes[1].device)

                self.assertEqual(IPv4_NET, rules[0].to)
                self.assertEqual(IPV4_TABLE, rules[0].table)
                self.assertEqual(nic, rules[0].iif)
                self.assertEqual(rules[0].prio, sourceroute.RULE_PRIORITY)
                self.assertEqual(IPv4_NET, rules[1].src)
                self.assertEqual(IPV4_TABLE, rules[1].table)
                self.assertEqual(rules[1].prio, sourceroute.RULE_PRIORITY)
Пример #16
0
 def add(addr_data):
     with _translate_iproute2_exception(IPAddressAddError, addr_data):
         ipwrapper.addrAdd(
             addr_data.device,
             addr_data.address,
             addr_data.prefixlen,
             addr_data.family,
         )
Пример #17
0
 def test_local_auto_with_static_address_without_ra_server(self):
     with dummy_device() as dev:
         ipwrapper.addrAdd(dev, '2001::88', '64', family=6)
         ip_addrs = addresses.getIpAddrs()[dev]
         assert addresses.is_ipv6_local_auto(dev)
         assert 2 == len(ip_addrs), ip_addrs
         assert addresses.is_ipv6(ip_addrs[0])
         assert not addresses.is_dynamic(ip_addrs[0])
Пример #18
0
    def test_attach_nic_with_ip_to_ipless_network(self):
        with dummy_device() as nic:
            addrAdd(nic, IPv4_ADDRESS, IPv4_PREFIX_LEN)

            NETCREATE = {NETWORK_NAME: {"nic": nic, "switch": self.switch}}
            with self.setupNetworks(NETCREATE, {}, NOCHK):
                nic_netinfo = self.netinfo.nics[nic]
                self.assertDisabledIPv4(nic_netinfo)
Пример #19
0
    def test_attach_nic_with_ip_to_ipless_network(self):
        with dummy_device() as nic:
            addrAdd(nic, IPv4_ADDRESS, IPv4_PREFIX_LEN)

            NETCREATE = {NETWORK_NAME: {'nic': nic, 'switch': self.switch}}
            with self.setupNetworks(NETCREATE, {}, NOCHK):
                nic_netinfo = self.netinfo.nics[nic]
                self.assertDisabledIPv4(nic_netinfo)
Пример #20
0
    def test_sourceroute_add_over_existing_route(self, nic0):
        addrAdd(nic0, IPV4_ADDRESS, IPV4_MASK)

        with create_sourceroute(device=nic0,
                                ip=IPV4_ADDRESS,
                                mask=IPV4_MASK,
                                gateway=IPV4_GW):
            sourceroute.add(nic0, IPV4_ADDRESS, IPV4_MASK, IPV4_GW)
Пример #21
0
 def test_local_auto_with_static_address_without_ra_server(self):
     with dummy_device() as dev:
         ipwrapper.addrAdd(dev, '2001::88', '64', family=6)
         ip_addrs = addresses.getIpAddrs()[dev]
         self.assertTrue(addresses.is_ipv6_local_auto(dev))
         self.assertEqual(2, len(ip_addrs))
         self.assertTrue(addresses.is_ipv6(ip_addrs[0]))
         self.assertTrue(not addresses.is_dynamic(ip_addrs[0]))
Пример #22
0
 def test_local_auto_with_static_address_without_ra_server(self):
     with dummy_device() as dev:
         ipwrapper.addrAdd(dev, '2001::88', '64', family=6)
         ip_addrs = addresses.getIpAddrs()[dev]
         self.assertTrue(addresses.is_ipv6_local_auto(dev))
         self.assertEqual(2, len(ip_addrs), ip_addrs)
         self.assertTrue(addresses.is_ipv6(ip_addrs[0]))
         self.assertTrue(not addresses.is_dynamic(ip_addrs[0]))
Пример #23
0
    def test_attach_nic_with_ip_to_ipless_network(self, switch):
        with dummy_device() as nic:
            addrAdd(nic, IPv4_ADDRESS, IPv4_PREFIX_LEN)

            NETCREATE = {NETWORK_NAME: {'nic': nic, 'switch': switch}}
            with adapter.setupNetworks(NETCREATE, {}, NOCHK):
                nic_netinfo = adapter.netinfo.nics[nic]
                adapter.assertDisabledIPv4(nic_netinfo)
Пример #24
0
 def add_ip(self, ip_addr, prefix_len, family):
     try:
         addrAdd(self.dev_name, ip_addr, prefix_len, family)
     except IPRoute2Error as e:
         message = (
             f'Failed to add the IPv{family} address {ip_addr}/{prefix_len}'
             f'to device {self.dev_name}: {e}')
         pytest.skip(message)
Пример #25
0
 def test_iperf_upper_limit(self):
     # Upper limit is not an accurate measure. This is because it converges
     # over time and depends on current machine hardware (CPU).
     # Hence, it is hard to make hard assertions on it. The test should run
     # at least 60 seconds (the longer the better) and the user should
     # inspect the computed average rate and optionally the additional
     # traffic data that was collected in client.out in order to be
     # convinced QOS is working properly.
     limit_kbps = 1000  # 1 Mbps (in kbps)
     server_ip = '192.0.2.1'
     client_ip = '192.0.2.10'
     qos_out = {'ul': {'m2': limit_kbps}, 'ls': {'m2': limit_kbps}}
     # using a network namespace is essential since otherwise the kernel
     # short-circuits the traffic and bypasses the veth devices and the
     # classfull qdisc.
     with network_namespace(
         'server_ns'
     ) as ns, bridge_device() as bridge, veth_pair() as (
         server_peer,
         server_dev,
     ), veth_pair() as (
         client_dev,
         client_peer,
     ):
         linkSet(server_peer, ['up'])
         linkSet(client_peer, ['up'])
         # iperf server and its veth peer lie in a separate network
         # namespace
         link_set_netns(server_dev, ns)
         bridge.addIf(server_peer)
         bridge.addIf(client_peer)
         linkSet(client_dev, ['up'])
         netns_exec(ns, ['ip', 'link', 'set', 'dev', server_dev, 'up'])
         addrAdd(client_dev, client_ip, 24)
         netns_exec(
             ns,
             [
                 'ip',
                 '-4',
                 'addr',
                 'add',
                 'dev',
                 server_dev,
                 '%s/24' % server_ip,
             ],
         )
         qos.configure_outbound(qos_out, client_peer, None)
         with running(IperfServer(server_ip, network_ns=ns)):
             client = IperfClient(server_ip, client_ip, test_time=60)
             client.start()
             max_rate = max(
                 [
                     float(interval['streams'][0]['bits_per_second'])
                     // (2 ** 10)
                     for interval in client.out['intervals']
                 ]
             )
             self.assertTrue(0 < max_rate < limit_kbps * 1.5)
Пример #26
0
    def test_attach_nic_with_ip_to_ipless_network(self, adapter, switch, nic0):
        addrAdd(nic0, IPv4_ADDRESS, IPv4_PREFIX_LEN)
        addrAdd(nic0, IPv6_ADDRESS, IPv6_PREFIX_LEN, family=6)

        NETCREATE = {NETWORK_NAME: {'nic': nic0, 'switch': switch}}
        with adapter.setupNetworks(NETCREATE, {}, NOCHK):
            nic_netinfo = adapter.netinfo.nics[nic0]
            adapter.assertDisabledIPv4(nic_netinfo)
            adapter.assertDisabledIPv6(nic_netinfo)
Пример #27
0
def add(iface, ipv4, ipv6):
    if ipv4.address:
        ipwrapper.addrAdd(iface, ipv4.address, ipv4.netmask)
        if ipv4.gateway and ipv4.defaultRoute:
            ipwrapper.routeAdd(['default', 'via', ipv4.gateway])
    if ipv6:
        _add_ipv6_address(iface, ipv6)
    elif ipv6_supported():
        sysctl.disable_ipv6(iface)
Пример #28
0
    def test_attach_nic_with_ip_as_a_slave_to_ipless_network(self):
        with dummy_devices(2) as (nic1, nic2):
            addrAdd(nic1, IPv4_ADDRESS, IPv4_PREFIX_LEN)

            NETCREATE = {NETWORK_NAME: {"bonding": BOND_NAME, "switch": self.switch}}
            BONDCREATE = {BOND_NAME: {"nics": [nic1, nic2], "switch": self.switch}}
            with self.setupNetworks(NETCREATE, BONDCREATE, NOCHK):
                nic_netinfo = self.netinfo.nics[nic1]
                self.assertDisabledIPv4(nic_netinfo)
Пример #29
0
def dynamic_ipv4_iface():
    with veth_pair() as (server, client):
        addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
        linkSet(server, ['up'])
        with dnsmasq_run(server,
                         DHCPv4_RANGE_FROM,
                         DHCPv4_RANGE_TO,
                         router=IPv4_ADDRESS):
            yield client
Пример #30
0
def add(iface, ipv4, ipv6):
    if ipv4.address:
        ipwrapper.addrAdd(iface, ipv4.address, ipv4.netmask)
        if ipv4.gateway and ipv4.defaultRoute:
            ipwrapper.routeAdd(['default', 'via', ipv4.gateway])
    if ipv6:
        _add_ipv6_address(iface, ipv6)
    elif ipv6_supported():
        sysctl.disable_ipv6(iface)
Пример #31
0
def _add_ipv6_address(iface, ipv6):
    if ipv6.address:
        ipv6addr, ipv6netmask = ipv6.address.split('/')
        ipwrapper.addrAdd(iface, ipv6addr, ipv6netmask, family=6)
        if ipv6.gateway and ipv6.defaultRoute:
            _set_default_route(ipv6.gateway, family=6, dev=iface)
    if ipv6.ipv6autoconf is not None:
        with open('/proc/sys/net/ipv6/conf/%s/autoconf' % iface,
                  'w') as ipv6_autoconf:
            ipv6_autoconf.write('1' if ipv6.ipv6autoconf else '0')
Пример #32
0
def _add_ipv6_address(iface, ipv6):
    if ipv6.address:
        ipv6addr, ipv6netmask = ipv6.address.split('/')
        ipwrapper.addrAdd(iface, ipv6addr, ipv6netmask, family=6)
        if ipv6.gateway and ipv6.defaultRoute:
            _set_default_route(ipv6.gateway, family=6, dev=iface)
    if ipv6.ipv6autoconf is not None:
        with open('/proc/sys/net/ipv6/conf/%s/autoconf' % iface,
                  'w') as ipv6_autoconf:
            ipv6_autoconf.write('1' if ipv6.ipv6autoconf else '0')
Пример #33
0
    def test_routes_device_to(self, ip_addr, ip_netmask, nic0):
        addr_in_net = ipaddress.ip_address(ip_addr) + 1
        ip_version = addr_in_net.version

        ipwrapper.addrAdd(nic0, ip_addr, ip_netmask, family=ip_version)
        try:
            ipwrapper.linkSet(nic0, ['up'])
            assert routes.getRouteDeviceTo(str(addr_in_net)) == nic0
        finally:
            ipwrapper.addrFlush(nic0, ip_version)
Пример #34
0
    def testDhcpReplaceNicWithBridge(self):
        with veth_pair() as (left, right):
            addrAdd(left, IP_ADDRESS, IP_CIDR)
            addrAdd(left, IPv6_ADDRESS, IPv6_CIDR, 6)
            linkSet(left, ['up'])
            with dnsmasq_run(left, DHCP_RANGE_FROM, DHCP_RANGE_TO,
                             DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO, IP_GATEWAY):

                # first, a network without a bridge should get a certain
                # address

                network = {
                    NETWORK_NAME: {
                        'nic': right,
                        'bridged': False,
                        'bootproto': 'dhcp',
                        'blockingdhcp': True
                    }
                }
                try:
                    status, msg = self.setupNetworks(network, {}, NOCHK)
                    self.assertEqual(status, SUCCESS, msg)
                    self.assertNetworkExists(NETWORK_NAME)

                    test_net = self.vdsm_net.netinfo.networks[NETWORK_NAME]
                    self.assertEqual(test_net['dhcpv4'], True)
                    devs = self.vdsm_net.netinfo.nics
                    device_name = right

                    self.assertIn(device_name, devs)
                    net_attrs = devs[device_name]
                    self.assertEqual(net_attrs['dhcpv4'], True)

                    self.assertEqual(test_net['gateway'], IP_GATEWAY)
                    ip_addr = test_net['addr']
                    self.assertSourceRoutingConfiguration(device_name, ip_addr)

                    # now, a bridged network should get the same address
                    # (because dhclient should send the same dhcp-client-
                    #  identifier)

                    network[NETWORK_NAME]['bridged'] = True
                    status, msg = self.setupNetworks(network, {}, NOCHK)
                    self.assertEqual(status, SUCCESS, msg)
                    test_net = self.vdsm_net.netinfo.networks[NETWORK_NAME]
                    self.assertEqual(ip_addr, test_net['addr'])

                    network = {NETWORK_NAME: {'remove': True}}
                    status, msg = self.setupNetworks(network, {}, NOCHK)
                    self.assertEqual(status, SUCCESS, msg)
                    self.assertNetworkDoesntExist(NETWORK_NAME)

                finally:
                    dhcp.delete_dhclient_leases(right, True, False)
                    dhcp.delete_dhclient_leases(NETWORK_NAME, True, False)
Пример #35
0
    def test_ip_info(self):
        def get_ip_info(*a, **kw):
            """filter away ipv6 link local addresses that may or may not exist
            on the device depending on OS configuration"""
            ipv4addr, ipv4netmask, ipv4addrs, ipv6addrs = \
                addresses.getIpInfo(*a, **kw)
            return ipv4addr, ipv4netmask, ipv4addrs, ipv6addrs

        IP_ADDR = '192.0.2.2'
        IP_ADDR_SECOND = '192.0.2.3'
        IP_ADDR_GW = '192.0.2.1'
        IP_ADDR2 = '198.51.100.9'
        IP_ADDR3 = '198.51.100.11'
        IP_ADDR2_GW = '198.51.100.1'
        IPV6_ADDR = '2607:f0d0:1002:51::4'
        NET_MASK = '255.255.255.0'
        PREFIX_LENGTH = 24
        IPV6_PREFIX_LENGTH = 64
        IP_ADDR_CIDR = self._cidr_form(IP_ADDR, PREFIX_LENGTH)
        IP_ADDR_2ND_CIDR = self._cidr_form(IP_ADDR_SECOND, PREFIX_LENGTH)
        IP_ADDR2_CIDR = self._cidr_form(IP_ADDR2, PREFIX_LENGTH)
        IP_ADDR3_CIDR = self._cidr_form(IP_ADDR3, 32)
        IPV6_ADDR_CIDR = self._cidr_form(IPV6_ADDR, IPV6_PREFIX_LENGTH)
        with dummy_device() as device:
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR_CIDR):
                ipwrapper.addrAdd(device, IP_ADDR, PREFIX_LENGTH)
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR_2ND_CIDR):
                ipwrapper.addrAdd(device, IP_ADDR_SECOND, PREFIX_LENGTH)
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR2_CIDR):
                ipwrapper.addrAdd(device, IP_ADDR2, PREFIX_LENGTH)
            with waitfor.waitfor_ipv6_addr(device, address=IPV6_ADDR_CIDR):
                ipwrapper.addrAdd(
                    device, IPV6_ADDR, IPV6_PREFIX_LENGTH, family=6)
            # 32 bit addresses are reported slashless by netlink
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR3):
                ipwrapper.addrAdd(device, IP_ADDR3, 32)

            self.assertEqual(
                get_ip_info(device),
                (IP_ADDR, NET_MASK,
                 [IP_ADDR_CIDR, IP_ADDR2_CIDR, IP_ADDR3_CIDR,
                  IP_ADDR_2ND_CIDR],
                 [IPV6_ADDR_CIDR]))
            self.assertEqual(
                get_ip_info(device, ipv4_gateway=IP_ADDR_GW),
                (IP_ADDR, NET_MASK,
                 [IP_ADDR_CIDR, IP_ADDR2_CIDR, IP_ADDR3_CIDR,
                  IP_ADDR_2ND_CIDR],
                 [IPV6_ADDR_CIDR]))
            self.assertEqual(
                get_ip_info(device, ipv4_gateway=IP_ADDR2_GW),
                (IP_ADDR2, NET_MASK,
                 [IP_ADDR_CIDR, IP_ADDR2_CIDR, IP_ADDR3_CIDR,
                  IP_ADDR_2ND_CIDR],
                 [IPV6_ADDR_CIDR]))
Пример #36
0
    def test_ip_info(self):
        def get_ip_info(*a, **kw):
            """filter away ipv6 link local addresses that may or may not exist
            on the device depending on OS configuration"""
            ipv4addr, ipv4netmask, ipv4addrs, ipv6addrs = \
                addresses.getIpInfo(*a, **kw)
            return ipv4addr, ipv4netmask, ipv4addrs, ipv6addrs

        IP_ADDR = '192.0.2.2'
        IP_ADDR_SECOND = '192.0.2.3'
        IP_ADDR_GW = '192.0.2.1'
        IP_ADDR2 = '198.51.100.9'
        IP_ADDR3 = '198.51.100.11'
        IP_ADDR2_GW = '198.51.100.1'
        IPV6_ADDR = '2607:f0d0:1002:51::4'
        NET_MASK = '255.255.255.0'
        PREFIX_LENGTH = 24
        IPV6_PREFIX_LENGTH = 64
        IP_ADDR_CIDR = self._cidr_form(IP_ADDR, PREFIX_LENGTH)
        IP_ADDR_2ND_CIDR = self._cidr_form(IP_ADDR_SECOND, PREFIX_LENGTH)
        IP_ADDR2_CIDR = self._cidr_form(IP_ADDR2, PREFIX_LENGTH)
        IP_ADDR3_CIDR = self._cidr_form(IP_ADDR3, 32)
        IPV6_ADDR_CIDR = self._cidr_form(IPV6_ADDR, IPV6_PREFIX_LENGTH)
        with dummy_device() as device:
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR_CIDR):
                ipwrapper.addrAdd(device, IP_ADDR, PREFIX_LENGTH)
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR_2ND_CIDR):
                ipwrapper.addrAdd(device, IP_ADDR_SECOND, PREFIX_LENGTH)
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR2_CIDR):
                ipwrapper.addrAdd(device, IP_ADDR2, PREFIX_LENGTH)
            with waitfor.waitfor_ipv6_addr(device, address=IPV6_ADDR_CIDR):
                ipwrapper.addrAdd(
                    device, IPV6_ADDR, IPV6_PREFIX_LENGTH, family=6)
            # 32 bit addresses are reported slashless by netlink
            with waitfor.waitfor_ipv4_addr(device, address=IP_ADDR3):
                ipwrapper.addrAdd(device, IP_ADDR3, 32)

            self.assertEqual(
                get_ip_info(device),
                (IP_ADDR, NET_MASK,
                 [IP_ADDR_CIDR, IP_ADDR2_CIDR, IP_ADDR3_CIDR,
                  IP_ADDR_2ND_CIDR],
                 [IPV6_ADDR_CIDR]))
            self.assertEqual(
                get_ip_info(device, ipv4_gateway=IP_ADDR_GW),
                (IP_ADDR, NET_MASK,
                 [IP_ADDR_CIDR, IP_ADDR2_CIDR, IP_ADDR3_CIDR,
                  IP_ADDR_2ND_CIDR],
                 [IPV6_ADDR_CIDR]))
            self.assertEqual(
                get_ip_info(device, ipv4_gateway=IP_ADDR2_GW),
                (IP_ADDR2, NET_MASK,
                 [IP_ADDR_CIDR, IP_ADDR2_CIDR, IP_ADDR3_CIDR,
                  IP_ADDR_2ND_CIDR],
                 [IPV6_ADDR_CIDR]))
Пример #37
0
    def test_attach_nic_with_ip_as_a_slave_to_ipless_network(self, switch):
        with dummy_devices(2) as (nic1, nic2):
            addrAdd(nic1, IPv4_ADDRESS, IPv4_PREFIX_LEN)

            NETCREATE = {
                NETWORK_NAME: {'bonding': BOND_NAME, 'switch': switch}}
            BONDCREATE = {
                BOND_NAME: {'nics': [nic1, nic2], 'switch': switch}}
            with adapter.setupNetworks(NETCREATE, BONDCREATE, NOCHK):
                nic_netinfo = adapter.netinfo.nics[nic1]
                adapter.assertDisabledIPv4(nic_netinfo)
Пример #38
0
 def set_ip(self, ipaddr, netmask, family=4):
     try:
         addrAdd(self.devName, ipaddr, netmask, family)
     except IPRoute2Error as e:
         message = ('Failed to add the IPv%s address %s/%s to device %s: %s'
                    % (family, ipaddr, netmask, self.devName, e))
         if family == 6:
             message += ("; NetworkManager may have set the sysctl "
                         "disable_ipv6 flag on the device, please see e.g. "
                         "RH BZ #1102064")
         raise SkipTest(message)
Пример #39
0
    def test_attach_nic_with_ip_as_a_slave_to_ipless_network(
            self, adapter, switch, nic0, nic1):
        addrAdd(nic0, IPv4_ADDRESS, IPv4_PREFIX_LEN)
        addrAdd(nic0, IPv6_ADDRESS, IPv6_PREFIX_LEN, family=6)

        NETCREATE = {NETWORK_NAME: {'bonding': BOND_NAME, 'switch': switch}}
        BONDCREATE = {BOND_NAME: {'nics': [nic0, nic1], 'switch': switch}}
        with adapter.setupNetworks(NETCREATE, BONDCREATE, NOCHK):
            nic_netinfo = adapter.netinfo.nics[nic0]
            adapter.assertDisabledIPv4(nic_netinfo)
            adapter.assertDisabledIPv6(nic_netinfo)
Пример #40
0
 def set_ip(self, ipaddr, netmask, family=4):
     try:
         addrAdd(self.devName, ipaddr, netmask, family)
     except IPRoute2Error as e:
         message = ('Failed to add the IPv%s address %s/%s to device %s: %s'
                    % (family, ipaddr, netmask, self.devName, e))
         if family == 6:
             message += ("; NetworkManager may have set the sysctl "
                         "disable_ipv6 flag on the device, please see e.g. "
                         "RH BZ #1102064")
         raise SkipTest(message)
Пример #41
0
def _add_ipv6_address(iface, ipv6):
    if ipv6.address:
        ipv6addr, ipv6netmask = ipv6.address.split('/')
        ipwrapper.addrAdd(iface, ipv6addr, ipv6netmask, family=6)
        if ipv6.gateway:
            ipwrapper.routeAdd(['default', 'via', ipv6.gateway],
                               dev=iface, family=6)
    if ipv6.ipv6autoconf is not None:
        with open('/proc/sys/net/ipv6/conf/%s/autoconf' % iface,
                  'w') as ipv6_autoconf:
            ipv6_autoconf.write('1' if ipv6.ipv6autoconf else '0')
Пример #42
0
    def test_attach_nic_with_ip_as_a_slave_to_ipless_network(self):
        with dummy_devices(2) as (nic1, nic2):
            addrAdd(nic1, IPv4_ADDRESS, IPv4_PREFIX_LEN)

            NETCREATE = {
                NETWORK_NAME: {'bonding': BOND_NAME, 'switch': self.switch}}
            BONDCREATE = {
                BOND_NAME: {'nics': [nic1, nic2], 'switch': self.switch}}
            with self.setupNetworks(NETCREATE, BONDCREATE, NOCHK):
                nic_netinfo = self.netinfo.nics[nic1]
                self.assertDisabledIPv4(nic_netinfo)
Пример #43
0
def dynamic_ipv6_iface():
    if running_on_ovirt_ci():
        pytest.skip('Using dnsmasq for ipv6 RA is unstable on CI')

    with veth_pair() as (server, client):
        ipwrapper.addrAdd(server, IPV6_ADDR1, IPV6_PREFIX_LENGTH, family=6)
        ipwrapper.linkSet(server, ['up'])
        with dnsmasq_run(server, ipv6_slaac_prefix=IPV6_NET_ADDR):
            with wait_for_ipv6(client):
                ipwrapper.linkSet(client, ['up'])
            yield client
Пример #44
0
    def _test_add_net_with_dhcpv4(self, bridged=False):

        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            linkSet(server, ['up'])
            with dnsmasq_run(server, DHCPv4_RANGE_FROM, DHCPv4_RANGE_TO):

                netcreate = {NETWORK_NAME: {
                    'bridged': bridged, 'nic': client, 'blockingdhcp': True,
                    'bootproto': 'dhcp', 'switch': self.switch}}

                with self.setupNetworks(netcreate, {}, NOCHK):
                    self.assertNetworkIp(
                        NETWORK_NAME, netcreate[NETWORK_NAME])
Пример #45
0
    def test_attach_dhcp_nic_to_ipless_network(self):
        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            linkSet(server, ["up"])
            with dnsmasq_run(server, DHCPv4_RANGE_FROM, DHCPv4_RANGE_TO):
                with dhclient_run(client):
                    self.assertDhclient(client, family=4)

                    NETCREATE = {NETWORK_NAME: {"nic": client, "switch": self.switch}}
                    with self.setupNetworks(NETCREATE, {}, NOCHK):
                        nic_netinfo = self.netinfo.nics[client]
                        self.assertDisabledIPv4(nic_netinfo)
                        net_netinfo = self.netinfo.networks[NETWORK_NAME]
                        self.assertDisabledIPv4(net_netinfo)
Пример #46
0
def _add_ipv6_address(iface, ipv6):
    if ipv6.address:
        ipv6addr, ipv6netmask = ipv6.address.split('/')
        try:
            ipwrapper.addrAdd(iface, ipv6addr, ipv6netmask, family=6)
        except ipwrapper.IPRoute2AlreadyExistsError:
            logging.warning(
                'IP address already exists: %s/%s', iface, ipv6addr)

        if ipv6.gateway and ipv6.defaultRoute:
            set_default_route(ipv6.gateway, family=6, dev=iface)
    if ipv6.ipv6autoconf is not None:
        with open('/proc/sys/net/ipv6/conf/%s/autoconf' % iface,
                  'w') as ipv6_autoconf:
            ipv6_autoconf.write('1' if ipv6.ipv6autoconf else '0')
Пример #47
0
    def _test_add_net_with_dhcpv4(self, bridged=False):

        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            linkSet(server, ["up"])
            with dnsmasq_run(server, DHCPv4_RANGE_FROM, DHCPv4_RANGE_TO):

                netcreate = {
                    NETWORK_NAME: {
                        "bridged": bridged,
                        "nic": client,
                        "blockingdhcp": True,
                        "bootproto": "dhcp",
                        "switch": self.switch,
                    }
                }

                with self.setupNetworks(netcreate, {}, NOCHK):
                    self.assertNetworkIp(NETWORK_NAME, netcreate[NETWORK_NAME])
Пример #48
0
    def test_attach_dhcp_nic_to_dhcpv6_bridged_network(self, switch):
        with veth_pair() as (server, client):
            addrAdd(server, IPv6_ADDRESS, IPv6_CIDR, IpFamily.IPv6)
            linkSet(server, ['up'])
            with dnsmasq_run(server, DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO):
                with dhclient_run(client, family=IpFamily.IPv6):
                    adapter.assertDhclient(client, family=IpFamily.IPv6)

                    NETCREATE = {NETWORK_NAME: {
                        'nic': client, 'dhcpv6': True,
                        'blockingdhcp': True, 'switch': switch}}
                    with adapter.setupNetworks(NETCREATE, {}, NOCHK):
                        nic_netinfo = adapter.netinfo.nics[client]
                        adapter.assertDisabledIPv6(nic_netinfo)
                        adapter.assertNoDhclient(client, family=IpFamily.IPv6)
                        net_netinfo = adapter.netinfo.networks[NETWORK_NAME]
                        adapter.assertDHCPv6(net_netinfo)
                        adapter.assertDhclient(NETWORK_NAME,
                                               family=IpFamily.IPv6)
Пример #49
0
 def _setIpConfig(self, iface):
     ipv4 = iface.ipv4
     ipv6 = iface.ipv6
     if ipv4.address or ipv6.address:
         self.removeIpConfig(iface)
     if ipv4.address:
         ipwrapper.addrAdd(iface.name, ipv4.address,
                           ipv4.netmask)
         if ipv4.gateway and ipv4.defaultRoute:
             ipwrapper.routeAdd(['default', 'via', ipv4.gateway])
     if ipv6.address:
         ipv6addr, ipv6netmask = ipv6.address.split('/')
         ipwrapper.addrAdd(iface.name, ipv6addr, ipv6netmask, family=6)
         if ipv6.gateway:
             ipwrapper.routeAdd(['default', 'via', ipv6.gateway],
                                dev=iface.name, family=6)
     if ipv6.ipv6autoconf is not None:
         with open('/proc/sys/net/ipv6/conf/%s/autoconf' % iface.name,
                   'w') as ipv6_autoconf:
             ipv6_autoconf.write('1' if ipv6.ipv6autoconf else '0')
Пример #50
0
    def test_attach_dhcp_nic_to_ipless_network(self, switch):
        with veth_pair() as (server, client):
            addrAdd(server, IPv4_ADDRESS, IPv4_PREFIX_LEN)
            addrAdd(server, IPv6_ADDRESS, IPv6_CIDR, IpFamily.IPv6)
            linkSet(server, ['up'])
            with dnsmasq_run(server, DHCPv4_RANGE_FROM, DHCPv4_RANGE_TO,
                             DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO,
                             router=DHCPv4_GATEWAY):
                with dhclient_run(client):
                    adapter.assertDhclient(client, family=IpFamily.IPv4)
                    adapter.assertDhclient(client, family=IpFamily.IPv6)

                    NETCREATE = {NETWORK_NAME: {
                        'nic': client, 'switch': switch}}
                    with adapter.setupNetworks(NETCREATE, {}, NOCHK):
                        nic_netinfo = adapter.netinfo.nics[client]
                        adapter.assertDisabledIPv4(nic_netinfo)
                        adapter.assertDisabledIPv6(nic_netinfo)
                        net_netinfo = adapter.netinfo.networks[NETWORK_NAME]
                        adapter.assertDisabledIPv4(net_netinfo)
                        adapter.assertDisabledIPv6(nic_netinfo)
Пример #51
0
    def test_sourceroute_add_remove_and_read(self):
        with dummy_device() as nic:
            addrAdd(nic, IPV4_ADDRESS, IPV4_MASK)

            with create_sourceroute(device=nic, ip=IPV4_ADDRESS,
                                    mask=IPV4_MASK, gateway=IPV4_GW):
                dsroute = DynamicSourceRoute(nic, None, None, None)
                routes, rules = dsroute.current_srconfig()

                self.assertEqual(2, len(routes), routes)
                self.assertEqual(2, len(rules), rules)

                self.assertEqual('0.0.0.0/0', routes[0].to)
                self.assertEqual(nic, routes[0].device)
                self.assertEqual(IPv4_NET, routes[1].to)
                self.assertEqual(nic, routes[1].device)

                self.assertEqual(IPv4_NET, rules[0].to)
                self.assertEqual(IPV4_TABLE, rules[0].table)
                self.assertEqual(nic, rules[0].iif)
                self.assertEqual(IPv4_NET, rules[1].src)
                self.assertEqual(IPV4_TABLE, rules[1].table)
Пример #52
0
 def test_iperf_upper_limit(self):
     # Upper limit is not an accurate measure. This is because it converges
     # over time and depends on current machine hardware (CPU).
     # Hence, it is hard to make hard assertions on it. The test should run
     # at least 60 seconds (the longer the better) and the user should
     # inspect the computed average rate and optionally the additional
     # traffic data that was collected in client.out in order to be
     # convinced QOS is working properly.
     limit_kbps = 1000  # 1 Mbps (in kbps)
     server_ip = '192.0.2.1'
     client_ip = '192.0.2.10'
     qos_out = {'ul': {'m2': limit_kbps}, 'ls': {'m2': limit_kbps}}
     # using a network namespace is essential since otherwise the kernel
     # short-circuits the traffic and bypasses the veth devices and the
     # classfull qdisc.
     with network_namespace('server_ns') as ns, bridge_device() as bridge, \
             veth_pair() as (server_peer, server_dev), \
             veth_pair() as (client_dev, client_peer):
         linkSet(server_peer, ['up'])
         linkSet(client_peer, ['up'])
         # iperf server and its veth peer lie in a separate network
         # namespace
         link_set_netns(server_dev, ns)
         bridge.addIf(server_peer)
         bridge.addIf(client_peer)
         linkSet(client_dev, ['up'])
         netns_exec(ns, ['ip', 'link', 'set', 'dev', server_dev, 'up'])
         addrAdd(client_dev, client_ip, 24)
         netns_exec(ns, ['ip', '-4', 'addr', 'add', 'dev', server_dev,
                         '%s/24' % server_ip])
         qos.configure_outbound(qos_out, client_peer, None)
         with running(IperfServer(server_ip, network_ns=ns)):
             client = IperfClient(server_ip, client_ip, test_time=60)
             client.start()
             max_rate = max([float(
                 interval['streams'][0]['bits_per_second']) / (2**10)
                 for interval in client.out['intervals']])
             self.assertTrue(0 < max_rate < limit_kbps * 1.5)
Пример #53
0
    def test_local_auto_with_dynamic_address_from_ra(self):
        IPV6_NETADDRESS = '2001:1:1:1'
        IPV6_NETPREFIX_LEN = '64'
        with veth_pair() as (server, client):
            ipwrapper.addrAdd(server, IPV6_NETADDRESS + '::1',
                              IPV6_NETPREFIX_LEN, family=6)
            ipwrapper.linkSet(server, ['up'])
            with dnsmasq_run(server, ipv6_slaac_prefix=IPV6_NETADDRESS + '::'):
                with wait_for_ipv6(client):
                    ipwrapper.linkSet(client, ['up'])

                # Expecting link and global addresses on client iface
                # The addresses are given randomly, so we sort them
                ip_addrs = sorted(addresses.getIpAddrs()[client],
                                  key=lambda ip: ip['address'])
                self.assertEqual(2, len(ip_addrs), ip_addrs)

                self.assertTrue(addresses.is_dynamic(ip_addrs[0]))
                self.assertEqual('global', ip_addrs[0]['scope'])
                self.assertEqual(IPV6_NETADDRESS,
                                 ip_addrs[0]['address'][:len(IPV6_NETADDRESS)])

                self.assertEqual('link', ip_addrs[1]['scope'])
Пример #54
0
    def test_ip_info(self):
        IPV4_ADDR1 = '192.168.99.2'
        IPV4_GATEWAY1 = '192.168.99.1'
        IPV4_ADDR2 = '192.168.199.2'
        IPV4_GATEWAY2 = '192.168.199.1'
        IPV4_ADDR3 = '192.168.200.2'
        IPV4_NETMASK = '255.255.255.0'
        IPV4_PREFIX_LENGTH = 24
        IPV6_ADDR = '2607:f0d0:1002:51::4'
        IPV6_PREFIX_LENGTH = 64

        IPV4_ADDR1_CIDR = self._cidr_form(IPV4_ADDR1, IPV4_PREFIX_LENGTH)
        IPV4_ADDR2_CIDR = self._cidr_form(IPV4_ADDR2, IPV4_PREFIX_LENGTH)
        IPV4_ADDR3_CIDR = self._cidr_form(IPV4_ADDR3, 32)
        IPV6_ADDR_CIDR = self._cidr_form(IPV6_ADDR, IPV6_PREFIX_LENGTH)

        with dummy_device() as device:
            with waitfor.waitfor_ipv4_addr(device, address=IPV4_ADDR1_CIDR):
                ipwrapper.addrAdd(device, IPV4_ADDR1, IPV4_PREFIX_LENGTH)
            with waitfor.waitfor_ipv4_addr(device, address=IPV4_ADDR2_CIDR):
                ipwrapper.addrAdd(device, IPV4_ADDR2, IPV4_PREFIX_LENGTH)
            with waitfor.waitfor_ipv6_addr(device, address=IPV6_ADDR_CIDR):
                ipwrapper.addrAdd(
                    device, IPV6_ADDR, IPV6_PREFIX_LENGTH, family=6)

            # 32 bit addresses are reported slashless by netlink
            with waitfor.waitfor_ipv4_addr(device, address=IPV4_ADDR3):
                ipwrapper.addrAdd(device, IPV4_ADDR3, 32)

            self.assertEqual(
                addresses.getIpInfo(device),
                (IPV4_ADDR1, IPV4_NETMASK,
                 [IPV4_ADDR1_CIDR, IPV4_ADDR2_CIDR, IPV4_ADDR3_CIDR],
                 [IPV6_ADDR_CIDR]))
            self.assertEqual(
                addresses.getIpInfo(device, ipv4_gateway=IPV4_GATEWAY1),
                (IPV4_ADDR1, IPV4_NETMASK,
                 [IPV4_ADDR1_CIDR, IPV4_ADDR2_CIDR, IPV4_ADDR3_CIDR],
                 [IPV6_ADDR_CIDR]))
            self.assertEqual(
                addresses.getIpInfo(device, ipv4_gateway=IPV4_GATEWAY2),
                (IPV4_ADDR2, IPV4_NETMASK,
                 [IPV4_ADDR1_CIDR, IPV4_ADDR2_CIDR, IPV4_ADDR3_CIDR],
                 [IPV6_ADDR_CIDR]))
Пример #55
0
    def testSetupNetworksAddDelDhcp(self, bridged, families):
        """Copied from networkTests.py, source_route checking changed from
        device_name to BRIDGE_NAME.
        """
        def _assert_applied(network_name, requested, reported):
            self.assertNetworkExists(network_name)
            reported_network = reported.networks[network_name]

            if requested['bridged']:
                reported_devices = reported.bridges
                device_name = network_name
            else:
                # CHANGED: always bridged
                pass
            self.assertIn(device_name, reported_devices)
            reported_device = reported_devices[device_name]

            requested_dhcpv4 = requested['bootproto'] == 'dhcp'
            self.assertEqual(reported_network['dhcpv4'], requested_dhcpv4)
            self.assertEqual(reported_network['dhcpv6'], requested['dhcpv6'])

            self.assertEqual(reported_device['dhcpv4'], requested_dhcpv4)
            self.assertEqual(reported_device['dhcpv6'], requested['dhcpv6'])

            if requested_dhcpv4:
                self.assertEqual(reported_network['gateway'], IP_GATEWAY)
                # TODO: source routing not ready for IPv6
                ip_addr = reported_network['addr']
                self.assertSourceRoutingConfiguration(BRIDGE_NAME,  # CHANGED
                                                      ip_addr)
                return device_name, ip_addr
            return None, None

        with veth_pair() as (left, right):
            addrAdd(left, IP_ADDRESS, IP_CIDR)
            addrAdd(left, IPv6_ADDRESS, IPv6_CIDR, 6)
            linkSet(left, ['up'])
            with dnsmasq_run(left, DHCP_RANGE_FROM, DHCP_RANGE_TO,
                             DHCPv6_RANGE_FROM, DHCPv6_RANGE_TO, IP_GATEWAY):
                dhcpv4 = 4 in families
                dhcpv6 = 6 in families
                bootproto = 'dhcp' if dhcpv4 else 'none'
                network = {NETWORK_NAME: {'nic': right, 'bridged': bridged,
                                          'bootproto': bootproto,
                                          'dhcpv6': dhcpv6,
                                          'blockingdhcp': True}}
                try:
                    status, msg = self.setupNetworks(network, {}, NOCHK)
                    self.assertEqual(status, SUCCESS, msg)

                    device_name, ip_addr = _assert_applied(
                        NETWORK_NAME, network[NETWORK_NAME],
                        self.vdsm_net.netinfo)

                    # Do not report DHCP from (typically still valid) leases
                    network[NETWORK_NAME]['bootproto'] = 'none'
                    network[NETWORK_NAME]['dhcpv6'] = False
                    status, msg = self.setupNetworks(network, {}, NOCHK)
                    self.assertEqual(status, SUCCESS, msg)

                    _assert_applied(NETWORK_NAME, network[NETWORK_NAME],
                                    self.vdsm_net.netinfo)

                    network = {NETWORK_NAME: {'remove': True}}
                    status, msg = self.setupNetworks(network, {}, NOCHK)
                    self.assertEqual(status, SUCCESS, msg)
                    self.assertNetworkDoesntExist(NETWORK_NAME)

                    # Assert that routes and rules don't exist
                    if dhcpv4:
                        source_route = _get_source_route(device_name, ip_addr)
                        for route in source_route._buildRoutes():
                            self.assertRouteDoesNotExist(route)
                        for rule in source_route._buildRules():
                            self.assertRuleDoesNotExist(rule)
                finally:
                    dhcp.delete_dhclient_leases(
                        NETWORK_NAME if bridged else right, dhcpv4, dhcpv6)
Пример #56
0
 def add(addr_data):
     with _translate_iproute2_exception(IPAddressAddError, addr_data):
         ipwrapper.addrAdd(
             addr_data.device,
             addr_data.address, addr_data.prefixlen, addr_data.family
         )
Пример #57
0
def _add_ipv4_address(iface, ipv4):
    ipwrapper.addrAdd(iface, ipv4.address, ipv4.netmask)
    if ipv4.gateway and ipv4.defaultRoute:
        _set_default_route(ipv4.gateway, family=4)