def __init__(self, labels=None, down_revision=None):
     if not labels:
         labels = set()
     self.branch_labels = labels
     self.down_revision = down_revision
     self.revision = utils.get_random_string(10)
     self.module = mock.MagicMock()

def patch_supported():
    seed = utils.get_random_string(6)
    name = "patchtest-" + seed
    peer_name = "peertest0-" + seed
    patch_name = "peertest1-" + seed
    with ovs_lib.OVSBridge(name) as br:
        port = br.add_patch_port(patch_name, peer_name)
        return port != ovs_lib.INVALID_OFPORT

def ovs_conntrack_supported():
    random_str = utils.get_random_string(6)
    br_name = "ovs-test-" + random_str

    with ovs_lib.OVSBridge(br_name) as br:
        try:
            br.set_protocols(
                "OpenFlow10,OpenFlow11,OpenFlow12,OpenFlow13,OpenFlow14")
        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 get_related_rand_names(prefixes, max_length=None):
    """Returns a list of the prefixes with the same random characters appended

    :param prefixes: A list of prefix strings
    :param max_length: The maximum length of each returned string
    :returns: A list with each prefix appended with the same random characters
    """

    if max_length:
        length = max_length - max(len(p) for p in prefixes)
        if length <= 0:
            raise ValueError("'max_length' must be longer than all prefixes")
    else:
        length = 8
    rndchrs = utils.get_random_string(length)
    return [p + rndchrs for p in prefixes]

def keepalived_ipv6_supported():
    """Check if keepalived supports IPv6 functionality.

    Validation is done as follows.
    1. Create a namespace.
    2. Create OVS bridge with two ports (ha_port and gw_port)
    3. Move the ovs ports to the namespace.
    4. Spawn keepalived process inside the namespace with IPv6 configuration.
    5. Verify if IPv6 address is assigned to gw_port.
    6. Verify if IPv6 default route is configured by keepalived.
    """

    random_str = utils.get_random_string(6)
    br_name = "ka-test-" + random_str
    ha_port = ha_router.HA_DEV_PREFIX + random_str
    gw_port = namespaces.INTERNAL_DEV_PREFIX + random_str
    gw_vip = 'fdf8:f53b:82e4::10/64'
    expected_default_gw = 'fe80:f816::1'

    with ovs_lib.OVSBridge(br_name) as br:
        with KeepalivedIPv6Test(ha_port, gw_port, gw_vip,
                                expected_default_gw) as ka:
            br.add_port(ha_port, ('type', 'internal'))
            br.add_port(gw_port, ('type', 'internal'))

            ha_dev = ip_lib.IPDevice(ha_port)
            gw_dev = ip_lib.IPDevice(gw_port)

            ha_dev.link.set_netns(ka.nsname)
            gw_dev.link.set_netns(ka.nsname)

            ha_dev.link.set_up()
            gw_dev.link.set_up()

            ka.configure()

            ka.start_keepalived_process()

            ka.verify_ipv6_address_assignment(gw_dev)

            default_gw = gw_dev.route.get_gateway(ip_version=6)
            if default_gw:
                default_gw = default_gw['gateway']

    return expected_default_gw == default_gw

def get_rand_name(max_length=None, prefix='test'):
    """Return a random string.

    The string will start with 'prefix' and will be exactly 'max_length'.
    If 'max_length' is None, then exactly 8 random characters, each
    hexadecimal, will be added. In case len(prefix) <= len(max_length),
    ValueError will be raised to indicate the problem.
    """

    if max_length:
        length = max_length - len(prefix)
        if length <= 0:
            raise ValueError("'max_length' must be bigger than 'len(prefix)'.")

    else:
        length = 8

    return prefix + utils.get_random_string(length)

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 = "br-test-%s" % utils.get_random_string(6)
    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 ofctl_arg_supported(root_helper, cmd, args):
    '''Verify if ovs-ofctl binary supports command with specific args.

    :param root_helper: utility to use when running shell cmds.
    :param cmd: ovs-vsctl command to use for test.
    :param args: arguments to test with command.
    :returns: a boolean if the args supported.
    '''
    supported = True
    br_name = 'br-test-%s' % common_utils.get_random_string(6)
    test_br = OVSBridge(br_name, root_helper)
    test_br.reset_bridge()

    full_args = ["ovs-ofctl", cmd, test_br.br_name] + args
    try:
        utils.execute(full_args, root_helper=root_helper)
    except Exception:
        supported = False

    test_br.destroy()
    return supported

def iproute2_vxlan_supported():
    ip = ip_lib.IPWrapper()
    name = "vxlantest-" + utils.get_random_string(4)
    port = ip.add_vxlan(name, 3000)
    ip.del_veth(name)
    return name == port.name

def ovs_geneve_supported(from_ip='192.0.2.3', to_ip='192.0.2.4'):
    name = "genevetest-" + utils.get_random_string(6)
    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 ovs_vxlan_supported(from_ip='192.0.2.1', to_ip='192.0.2.2'):
    name = "vxlantest-" + utils.get_random_string(6)
    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 test_get_random_string(self):
     length = 127
     random_string = utils.get_random_string(length)
     self.assertEqual(length, len(random_string))
     regex = re.compile('^[0-9a-fA-F]+$')
     self.assertIsNotNone(regex.match(random_string))

def generate_tap_device_name():
    return n_consts.TAP_DEVICE_PREFIX + common_utils.get_random_string(
        n_consts.DEVICE_NAME_MAX_LEN - len(n_consts.TAP_DEVICE_PREFIX))

 def setUp(self):
     super(TestResourceAllocator, self).setUp()
     self.ra = resource_allocator.ResourceAllocator(
         utils.get_random_string(6), lambda: 42)
     self.addCleanup(safe_remove_file, self.ra._state_file_path)