def test_install_flood_to_tun(self):
        attrs = {
            'remote_ip': '192.0.2.1',  # RFC 5737 TEST-NET-1
            'local_ip': '198.51.100.1',  # RFC 5737 TEST-NET-2
        }
        kwargs = {'vlan': 777, 'tun_id': 888}
        port_name = tests_base.get_rand_device_name(net_helpers.PORT_PREFIX)
        ofport = self.br_tun.add_tunnel_port(port_name, attrs['remote_ip'],
                                             attrs['local_ip'])
        self.br_tun.install_flood_to_tun(ports=[ofport], **kwargs)
        test_packet = ("icmp,in_port=%d," % self.tun_p +
                       "dl_src=12:34:56:ab:cd:ef,dl_dst=12:34:56:78:cc:dd,"
                       "nw_src=192.168.0.1,nw_dst=192.168.0.2,nw_ecn=0,"
                       "nw_tos=0,nw_ttl=128,icmp_type=8,icmp_code=0,"
                       "dl_vlan=%(vlan)d,dl_vlan_pcp=0" % kwargs)
        trace = self._run_trace(self.tun_br.br_name, test_packet)
        self.assertTrue(("tun_id=0x%(tun_id)x" % kwargs) in
                        trace["Final flow"])
        self.assertTrue("vlan_tci=0x0000," in trace["Final flow"])

        self.br_tun.delete_flood_to_tun(kwargs['vlan'])

        trace = self._run_trace(self.tun_br.br_name, test_packet)
        self.assertEqual(" unchanged", trace["Final flow"])
        self.assertTrue("drop" in trace["Datapath actions"])

 def test_add_patch_port(self):
     local = tests_base.get_rand_device_name(net_helpers.PORT_PREFIX)
     peer = 'remotepeer'
     self.br.add_patch_port(local, peer)
     self.assertEqual(self.ovs.db_get_val('Interface', local, 'type'),
                      'patch')
     options = self.ovs.db_get_val('Interface', local, 'options')
     self.assertEqual(peer, options['peer'])

 def _test_add_tunnel_port(self, attrs):
     port_name = tests_base.get_rand_device_name(net_helpers.PORT_PREFIX)
     self.br.add_tunnel_port(port_name, attrs['remote_ip'],
                             attrs['local_ip'])
     self.assertEqual('gre',
                      self.ovs.db_get_val('Interface', port_name, 'type'))
     options = self.ovs.db_get_val('Interface', port_name, 'options')
     for attr, val in attrs.items():
         self.assertEqual(val, options[attr])

def create_patch_ports(source, destination):
    """Hook up two OVS bridges.

    The result is two patch ports, each end connected to a bridge.
    The two patch port names will start with 'patch-', followed by identical
    four characters. For example patch-xyzw-fedora, and patch-xyzw-ubuntu,
    where fedora and ubuntu are random strings.

    :param source: Instance of OVSBridge
    :param destination: Instance of OVSBridge
    """
    common = tests_base.get_rand_name(max_length=4, prefix='')
    prefix = '%s-%s-' % (PATCH_PREFIX, common)

    source_name = tests_base.get_rand_device_name(prefix=prefix)
    destination_name = tests_base.get_rand_device_name(prefix=prefix)

    source.add_patch_port(source_name, destination_name)
    destination.add_patch_port(destination_name, source_name)

def ovs_conntrack_supported():
    br_name = base.get_rand_device_name(prefix="ovs-test-")

    with ovs_lib.OVSBridge(br_name) as br:
        try:
            br.set_protocols(["OpenFlow%d" % i for i in range(10, 15)])
        except RuntimeError as e:
            LOG.debug("Exception while checking ovs conntrack support: %s", e)
            return False
    return ofctl_arg_supported(cmd='add-flow', ct_state='+trk', actions='drop')

 def test_replace_port(self):
     port_name = tests_base.get_rand_device_name(net_helpers.PORT_PREFIX)
     self.br.replace_port(port_name, ('type', 'internal'))
     self.assertTrue(self.br.port_exists(port_name))
     self.assertEqual('internal',
                      self.br.db_get_val('Interface', port_name, 'type'))
     self.br.replace_port(port_name, ('type', 'internal'),
                          ('external_ids', {'test': 'test'}))
     self.assertTrue(self.br.port_exists(port_name))
     self.assertEqual('test', self.br.db_get_val('Interface', port_name,
                                                 'external_ids')['test'])

 def test_add_tunnel_port(self):
     attrs = {
         'remote_ip': '192.0.2.1',  # RFC 5737 TEST-NET-1
         'local_ip': '198.51.100.1',  # RFC 5737 TEST-NET-2
     }
     port_name = tests_base.get_rand_device_name(net_helpers.PORT_PREFIX)
     self.br.add_tunnel_port(port_name, attrs['remote_ip'],
                             attrs['local_ip'])
     self.assertEqual(self.ovs.db_get_val('Interface', port_name, 'type'),
                      'gre')
     options = self.ovs.db_get_val('Interface', port_name, 'options')
     for attr, val in attrs.items():
         self.assertEqual(val, options[attr])

    def _setUp(self):
        super(OVSPortFixture, self)._setUp()

        interface_config = cfg.ConfigOpts()
        interface_config.register_opts(interface.OPTS)
        ovs_interface = interface.OVSInterfaceDriver(interface_config)

        port_name = tests_base.get_rand_device_name(PORT_PREFIX)
        ovs_interface.plug_new(
            None,
            self.port_id,
            port_name,
            self.mac,
            bridge=self.bridge.br_name,
            namespace=self.namespace)
        self.addCleanup(self.bridge.delete_port, port_name)
        self.port = ip_lib.IPDevice(port_name, self.namespace)

def ofctl_arg_supported(cmd, **kwargs):
    """Verify if ovs-ofctl binary supports cmd with **kwargs.

    :param cmd: ovs-ofctl command to use for test.
    :param **kwargs: arguments to test with the command.
    :returns: a boolean if the supplied arguments are supported.
    """
    br_name = base.get_rand_device_name(prefix='br-test-')
    with ovs_lib.OVSBridge(br_name) as test_br:
        full_args = ["ovs-ofctl", cmd, test_br.br_name,
                     ovs_lib._build_flow_expr_str(kwargs, cmd.split('-')[0])]
        try:
            agent_utils.execute(full_args, run_as_root=True)
        except RuntimeError as e:
            LOG.debug("Exception while checking supported feature via "
                      "command %s. Exception: %s", full_args, e)
            return False
        except Exception:
            LOG.exception(_LE("Unexpected exception while checking supported"
                              " feature via command: %s"), full_args)
            return False
        else:
            return True

 def _generate_tun_peer(self):
     return base.get_rand_device_name(prefix='patch-int')

 def create_ovs_port(self, *interface_attrs):
     # Convert ((a, b), (c, d)) to {a: b, c: d} and add 'type' by default
     attrs = collections.OrderedDict(interface_attrs)
     attrs.setdefault('type', 'internal')
     port_name = tests_base.get_rand_device_name(net_helpers.PORT_PREFIX)
     return (port_name, self.br.add_port(port_name, *attrs.items()))

def ovs_geneve_supported(from_ip='192.0.2.3', to_ip='192.0.2.4'):
    name = base.get_rand_device_name(prefix='genevetest-')
    with ovs_lib.OVSBridge(name) as br:
        port = br.add_tunnel_port(from_ip, to_ip, const.TYPE_GENEVE)
        return port != ovs_lib.INVALID_OFPORT

def iproute2_vxlan_supported():
    ip = ip_lib.IPWrapper()
    name = base.get_rand_device_name(prefix='vxlantest-')
    port = ip.add_vxlan(name, 3000)
    ip.del_veth(name)
    return name == port.name

 def get_veth_name(name):
     if name.startswith(VETH0_PREFIX):
         return tests_base.get_rand_device_name(VETH0_PREFIX)
     if name.startswith(VETH1_PREFIX):
         return tests_base.get_rand_device_name(VETH1_PREFIX)
     return name

 def _generate_external_bridge(self):
     return base.get_rand_device_name(prefix='br-ex')

def ovs_vxlan_supported(from_ip='192.0.2.1', to_ip='192.0.2.2'):
    name = base.get_rand_device_name(prefix='vxlantest-')
    with ovs_lib.OVSBridge(name) as br:
        port = br.add_tunnel_port(from_ip, to_ip, const.TYPE_VXLAN)
        return port != ovs_lib.INVALID_OFPORT

 def _generate_tunnel_bridge(self):
     return base.get_rand_device_name(prefix='br-tun')

 def _generate_integration_bridge(self):
     return base.get_rand_device_name(prefix='br-int')

 def _generate_bridge_mappings(self):
     return 'physnet1:%s' % base.get_rand_device_name(prefix='br-eth')