Python uuidutils.generate_uuid函数代码示例

    def test_create_for_sg_rule(self):
        sg_id = uuidutils.generate_uuid()
        sg_name = 'test-sg'
        in_chain_id = uuidutils.generate_uuid()
        out_chain_id = uuidutils.generate_uuid()
        self.mock_api_cfg.chains_in = [
            _create_test_sg_in_chain(sg_id, sg_name, in_chain_id,
                                     self._tenant_id),
            _create_test_sg_out_chain(sg_id, sg_name, out_chain_id,
                                      self._tenant_id)]

        sg_rule_id = uuidutils.generate_uuid()
        sg_rule = _create_test_sg_rule(self._tenant_id, sg_id, sg_rule_id)

        props = {"os_sg_rule_id": sg_rule_id}
        calls = [mock.call.add_rule().port_group(None).type(
            'accept').nw_proto(6).nw_src_address(
                '192.168.1.0').nw_src_length(24).tp_src_start(
                    None).tp_src_end(None).tp_dst_start(1).tp_dst_end(
                        65535).properties(props).create()]

        self.client.create_for_sg_rule(sg_rule)

        # Egress chain rule added
        self.mock_api_cfg.chains_out[0].assert_has_calls(calls)

    def create_security_group(self, context, security_group, default_sg=False):
        """Create security group.
        If default_sg is true that means we are a default security group for
        a given tenant if it does not exist.
        """
        s = security_group['security_group']
        tenant_id = self._get_tenant_id_for_create(context, s)

        if not default_sg:
            self._ensure_default_security_group(context, tenant_id)

        with context.session.begin(subtransactions=True):
            security_group_db = SecurityGroup(id=s.get('id') or (
                                              uuidutils.generate_uuid()),
                                              description=s['description'],
                                              tenant_id=tenant_id,
                                              name=s['name'])
            context.session.add(security_group_db)
            if s.get('name') == 'default':
                for ethertype in ext_sg.sg_supported_ethertypes:
                    # Allow intercommunication
                    db = SecurityGroupRule(
                        id=uuidutils.generate_uuid(), tenant_id=tenant_id,
                        security_group=security_group_db,
                        direction='ingress',
                        ethertype=ethertype,
                        source_group=security_group_db)
                    context.session.add(db)

        return self._make_security_group_dict(security_group_db)

 def get_random_params(self):
     """create random parameters for portinfo test"""
     tenant = uuidutils.generate_uuid()
     network = uuidutils.generate_uuid()
     port = uuidutils.generate_uuid()
     _filter = uuidutils.generate_uuid()
     none = uuidutils.generate_uuid()
     return tenant, network, port, _filter, none

 def get_ofc_item_random_params(self):
     """create random parameters for ofc_item test"""
     tenant_id = uuidutils.generate_uuid()
     network_id = uuidutils.generate_uuid()
     port_id = uuidutils.generate_uuid()
     portinfo = nmodels.PortInfo(
         id=port_id, datapath_id="0x123456789", port_no=1234, vlan_id=321, mac="11:22:33:44:55:66"
     )
     return tenant_id, network_id, portinfo

 def get_portinfo_random_params(self):
     """create random parameters for portinfo test"""
     port_id = uuidutils.generate_uuid()
     datapath_id = hex(random.randint(0, 0xffffffff))
     port_no = random.randint(1, 100)
     vlan_id = random.randint(0, 4095)
     mac = ':'.join(["%02x" % random.randint(0, 0xff) for x in range(6)])
     none = uuidutils.generate_uuid()
     return port_id, datapath_id, port_no, vlan_id, mac, none

 def get_ofc_item_random_params(self):
     """create random parameters for ofc_item test."""
     tenant_id = uuidutils.generate_uuid()
     network_id = uuidutils.generate_uuid()
     port_id = uuidutils.generate_uuid()
     mac = ':'.join(['%x' % random.randint(0, 255) for i in xrange(6)])
     portinfo = nmodels.PortInfo(id=port_id, datapath_id="0x123456789",
                                 port_no=1234, vlan_id=321,
                                 mac=mac)
     return tenant_id, network_id, portinfo

    def test_get_port_groups_for_sg(self):
        sg_id = uuidutils.generate_uuid()
        pg_id = uuidutils.generate_uuid()
        self.mock_api_cfg.port_groups_in = [
            _create_test_port_group(sg_id, 'test-sg', pg_id, self._tenant_id)]

        pg = self.client.get_port_groups_for_sg(self._tenant_id, sg_id)

        self.assertIsNotNone(pg)
        self.assertEqual(pg.get_id(), pg_id)

    def test_get_ready_devices_multiple_vips_and_pools(self):
        ctx = context.get_admin_context()

        # add 3 pools and 2 vips directly to DB
        # to create 2 "ready" devices and one pool without vip
        pools = []
        for i in xrange(0, 3):
            pools.append(
                ldb.Pool(
                    id=uuidutils.generate_uuid(),
                    subnet_id=self._subnet_id,
                    protocol="HTTP",
                    lb_method="ROUND_ROBIN",
                    status=constants.ACTIVE,
                    admin_state_up=True,
                )
            )
            ctx.session.add(pools[i])

        vip0 = ldb.Vip(
            id=uuidutils.generate_uuid(),
            protocol_port=80,
            protocol="HTTP",
            pool_id=pools[0].id,
            status=constants.ACTIVE,
            admin_state_up=True,
            connection_limit=3,
        )
        ctx.session.add(vip0)
        pools[0].vip_id = vip0.id

        vip1 = ldb.Vip(
            id=uuidutils.generate_uuid(),
            protocol_port=80,
            protocol="HTTP",
            pool_id=pools[1].id,
            status=constants.ACTIVE,
            admin_state_up=True,
            connection_limit=3,
        )
        ctx.session.add(vip1)
        pools[1].vip_id = vip1.id

        ctx.session.flush()

        self.assertEqual(ctx.session.query(ldb.Pool).count(), 3)
        self.assertEqual(ctx.session.query(ldb.Vip).count(), 2)
        ready = self.callbacks.get_ready_devices(ctx)
        self.assertEqual(len(ready), 2)
        self.assertIn(pools[0].id, ready)
        self.assertIn(pools[1].id, ready)
        self.assertNotIn(pools[2].id, ready)
        # cleanup
        ctx.session.query(ldb.Pool).delete()
        ctx.session.query(ldb.Vip).delete()

 def test_delete_quantum_ports(self):
     port1 = ovs_lib.VifPort('tap1234', 1, uuidutils.generate_uuid(),
                             'ca:fe:de:ad:be:ef', 'br')
     port2 = ovs_lib.VifPort('tap5678', 2, uuidutils.generate_uuid(),
                             'ca:ee:de:ad:be:ef', 'br')
     self.mox.StubOutWithMock(self.br, 'get_vif_ports')
     self.br.get_vif_ports().AndReturn([port1, port2])
     self.mox.StubOutWithMock(self.br, 'delete_port')
     self.br.delete_port('tap1234')
     self.br.delete_port('tap5678')
     self.mox.ReplayAll()
     self.br.delete_ports(all_ports=False)
     self.mox.VerifyAll()

 def test_collect_quantum_ports(self):
     port1 = ovs_lib.VifPort('tap1234', 1, uuidutils.generate_uuid(),
                             '11:22:33:44:55:66', 'br')
     port2 = ovs_lib.VifPort('tap5678', 2, uuidutils.generate_uuid(),
                             '77:88:99:aa:bb:cc', 'br')
     port3 = ovs_lib.VifPort('tap90ab', 3, uuidutils.generate_uuid(),
                             '99:00:aa:bb:cc:dd', 'br')
     ports = [[port1, port2], [port3]]
     portnames = [p.port_name for p in itertools.chain(*ports)]
     with mock.patch('quantum.agent.linux.ovs_lib.OVSBridge') as ovs:
         ovs.return_value.get_vif_ports.side_effect = ports
         bridges = ['br-int', 'br-ex']
         ret = util.collect_quantum_ports(bridges, 'dummy_sudo')
         self.assertEqual(ret, portnames)

    def create_security_group(self, context, security_group, default_sg=False):
        """Create security group.
        If default_sg is true that means we are a default security group for
        a given tenant if it does not exist.
        """
        s = security_group['security_group']
        if (cfg.CONF.SECURITYGROUP.proxy_mode and not context.is_admin):
            raise ext_sg.SecurityGroupProxyModeNotAdmin()
        if (cfg.CONF.SECURITYGROUP.proxy_mode and not s.get('external_id')):
            raise ext_sg.SecurityGroupProxyMode()
        if not cfg.CONF.SECURITYGROUP.proxy_mode and s.get('external_id'):
            raise ext_sg.SecurityGroupNotProxyMode()

        tenant_id = self._get_tenant_id_for_create(context, s)

        # if in proxy mode a default security group will be created by source
        if not default_sg and not cfg.CONF.SECURITYGROUP.proxy_mode:
            self._ensure_default_security_group(context, tenant_id,
                                                security_group)
        if s.get('external_id'):
            try:
                # Check if security group already exists
                sg = self.get_security_group(context, s.get('external_id'))
                if sg:
                    raise ext_sg.SecurityGroupAlreadyExists(
                        name=sg.get('name', ''),
                        external_id=s.get('external_id'))
            except ext_sg.SecurityGroupNotFound:
                pass

        with context.session.begin(subtransactions=True):
            security_group_db = SecurityGroup(id=s.get('id') or (
                                              uuidutils.generate_uuid()),
                                              description=s['description'],
                                              tenant_id=tenant_id,
                                              name=s['name'],
                                              external_id=s.get('external_id'))
            context.session.add(security_group_db)
            if s.get('name') == 'default':
                for ethertype in ext_sg.sg_supported_ethertypes:
                    # Allow intercommunication
                    db = SecurityGroupRule(
                        id=uuidutils.generate_uuid(), tenant_id=tenant_id,
                        security_group=security_group_db,
                        direction='ingress',
                        ethertype=ethertype,
                        source_group=security_group_db)
                    context.session.add(db)

        return self._make_security_group_dict(security_group_db)

    def create_member(self, context, member):
        v = member["member"]
        tenant_id = self._get_tenant_id_for_create(context, v)

        with context.session.begin(subtransactions=True):
            pool = None
            try:
                qry = context.session.query(Pool)
                pool = qry.filter_by(id=v["pool_id"]).one()
            except exc.NoResultFound:
                raise loadbalancer.PoolNotFound(pool_id=v["pool_id"])

            member_db = Member(
                id=uuidutils.generate_uuid(),
                tenant_id=tenant_id,
                pool_id=v["pool_id"],
                address=v["address"],
                protocol_port=v["protocol_port"],
                weight=v["weight"],
                admin_state_up=v["admin_state_up"],
                status=constants.PENDING_CREATE,
            )
            context.session.add(member_db)

        return self._make_member_dict(member_db)

    def create_port(self, ofc_network_id, portinfo, port_id=None):
        #NOTE: This Driver create slices with Port-MAC Based bindings on Trema
        #      Sliceable.  It's REST API requires Port Based binding before you
        #      define Port-MAC Based binding.
        ofc_port_id = port_id or uuidutils.generate_uuid()
        dummy_port_id = "dummy-%s" % ofc_port_id

        path = self.ports_path % {'network': ofc_network_id}
        body = {'id': dummy_port_id,
                'datapath_id': portinfo.datapath_id,
                'port': str(portinfo.port_no),
                'vid': str(portinfo.vlan_id)}
        self.client.post(path, body=body)

        path = self.attachments_path % {'network': ofc_network_id,
                                        'port': dummy_port_id}
        body = {'id': ofc_port_id, 'mac': portinfo.mac}
        self.client.post(path, body=body)

        path = self.port_path % {'network': ofc_network_id,
                                 'port': dummy_port_id}
        self.client.delete(path)

        return self.attachment_path % {'network': ofc_network_id,
                                       'port': dummy_port_id,
                                       'attachment': ofc_port_id}

    def test_fields(self):
        return_value = {"name": "net1", "admin_state_up": True, "subnets": []}

        instance = self.plugin.return_value
        instance.get_network.return_value = return_value

        self.api.get(_get_path("networks", id=uuidutils.generate_uuid()))

 def create_dummy(self, context, dummy):
     d = dummy['dummy']
     d['id'] = uuidutils.generate_uuid()
     self.dummys[d['id']] = d
     self.svctype_mgr.increase_service_type_refcount(context,
                                                     d['service_type'])
     return d