Python n1kv_db_v2.create_network_profile函数代码示例

    def _make_test_profile(self,
                           name='default_network_profile',
                           segment_type=c_const.NETWORK_TYPE_VLAN,
                           segment_range='386-400'):
        """
        Create a profile record for testing purposes.

        :param name: string representing the name of the network profile to
                     create. Default argument value chosen to correspond to the
                     default name specified in config.py file.
        :param segment_type: string representing the type of network segment.
        :param segment_range: string representing the segment range for network
                              profile.
        """
        db_session = db.get_session()
        profile = {'name': name,
                   'segment_type': segment_type,
                   'tenant_id': self.tenant_id,
                   'segment_range': segment_range}
        if segment_type == c_const.NETWORK_TYPE_OVERLAY:
            profile['sub_type'] = 'unicast'
            profile['multicast_ip_range'] = '0.0.0.0'
            net_p = n1kv_db_v2.create_network_profile(db_session, profile)
            n1kv_db_v2.sync_vxlan_allocations(db_session, net_p)
        elif segment_type == c_const.NETWORK_TYPE_VLAN:
            profile['physical_network'] = PHYS_NET
            net_p = n1kv_db_v2.create_network_profile(db_session, profile)
            n1kv_db_v2.sync_vlan_allocations(db_session, net_p)
        return net_p

 def test_get_network_profiles(self):
     test_profiles = [{'name': 'test_profile1',
                       'segment_type': 'vlan',
                       'physical_network': 'phys1',
                       'segment_range': '200-210'},
                      {'name': 'test_profile2',
                       'segment_type': 'vlan',
                       'physical_network': 'phys1',
                       'segment_range': '211-220'},
                      {'name': 'test_profile3',
                       'segment_type': 'vlan',
                       'physical_network': 'phys1',
                       'segment_range': '221-230'},
                      {'name': 'test_profile4',
                       'segment_type': 'vlan',
                       'physical_network': 'phys1',
                       'segment_range': '231-240'},
                      {'name': 'test_profile5',
                       'segment_type': 'vlan',
                       'physical_network': 'phys1',
                       'segment_range': '241-250'},
                      {'name': 'test_profile6',
                       'segment_type': 'vlan',
                       'physical_network': 'phys1',
                       'segment_range': '251-260'},
                      {'name': 'test_profile7',
                       'segment_type': 'vlan',
                       'physical_network': 'phys1',
                       'segment_range': '261-270'}]
     [n1kv_db_v2.create_network_profile(self.session, p)
      for p in test_profiles]
     # TODO(abhraut): Fix this test to work with real tenant_td
     profiles = n1kv_db_v2._get_network_profiles(db_session=self.session)
     self.assertEqual(len(test_profiles), len(list(profiles)))

 def test_get_network_profile(self):
     profile = n1kv_db_v2.create_network_profile(self.session,
                                                 TEST_NETWORK_PROFILE)
     got_profile = n1kv_db_v2.get_network_profile(self.session, profile.id)
     self.assertEqual(profile.id, got_profile.id)
     self.assertEqual(profile.name, got_profile.name)
     n1kv_db_v2.delete_network_profile(self.session, profile.id)

    def test_create_network_profile_overlap(self):
        _db_profile = n1kv_db_v2.create_network_profile(self.session,
                                                        TEST_NETWORK_PROFILE_2)
        ctx = context.get_admin_context()
        TEST_NETWORK_PROFILE_2['name'] = 'net-profile-min-overlap'
        TEST_NETWORK_PROFILE_2['segment_range'] = SEGMENT_RANGE_MIN_OVERLAP
        test_net_profile = {'network_profile': TEST_NETWORK_PROFILE_2}
        self.assertRaises(n_exc.InvalidInput,
                          self.create_network_profile,
                          ctx,
                          test_net_profile)

        TEST_NETWORK_PROFILE_2['name'] = 'net-profile-max-overlap'
        TEST_NETWORK_PROFILE_2['segment_range'] = SEGMENT_RANGE_MAX_OVERLAP
        test_net_profile = {'network_profile': TEST_NETWORK_PROFILE_2}
        self.assertRaises(n_exc.InvalidInput,
                          self.create_network_profile,
                          ctx,
                          test_net_profile)

        TEST_NETWORK_PROFILE_2['name'] = 'net-profile-overlap'
        TEST_NETWORK_PROFILE_2['segment_range'] = SEGMENT_RANGE_OVERLAP
        test_net_profile = {'network_profile': TEST_NETWORK_PROFILE_2}
        self.assertRaises(n_exc.InvalidInput,
                          self.create_network_profile,
                          ctx,
                          test_net_profile)
        n1kv_db_v2.delete_network_profile(self.session, _db_profile.id)

def _fake_add_dummy_profile_for_test(self, obj):
    """
    Replacement for a function in the N1KV neutron plugin module.

    Since VSM is not available at the time of tests, we have no
    policy profiles. Hence we inject a dummy policy/network profile into the
    port/network object.
    """
    dummy_profile_name = "dummy_profile"
    dummy_tenant_id = "test-tenant"
    db_session = db.get_session()
    if 'port' in obj:
        dummy_profile_id = "00000000-1111-1111-1111-000000000000"
        self._add_policy_profile(dummy_profile_name,
                                 dummy_profile_id,
                                 dummy_tenant_id)
        obj['port'][n1kv_profile.PROFILE_ID] = dummy_profile_id
    elif 'network' in obj:
        profile = {'name': 'dummy_profile',
                   'segment_type': 'vlan',
                   'physical_network': 'phsy1',
                   'segment_range': '3968-4047'}
        self.network_vlan_ranges = {profile[
            'physical_network']: [(3968, 4047)]}
        n1kv_db_v2.sync_vlan_allocations(db_session, self.network_vlan_ranges)
        np = n1kv_db_v2.create_network_profile(db_session, profile)
        obj['network'][n1kv_profile.PROFILE_ID] = np.id

    def test_vxlan_pool(self):
        vxlan_ids = set()
        profile = n1kv_db_v2.create_network_profile(self.session,
                                                    TEST_NETWORK_PROFILE_VXLAN)
        for x in xrange(VXLAN_MIN, VXLAN_MAX + 1):
            vxlan = n1kv_db_v2.reserve_vxlan(self.session, profile)
            vxlan_id = vxlan[2]
            self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1))
            self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1))
            vxlan_ids.add(vxlan_id)

        self.assertRaises(q_exc.NoNetworkAvailable,
                          n1kv_db_v2.reserve_vxlan,
                          self.session,
                          profile)
        n1kv_db_v2.release_vxlan(self.session, vxlan_ids.pop(), VXLAN_RANGES)
        vxlan = n1kv_db_v2.reserve_vxlan(self.session, profile)
        vxlan_id = vxlan[2]
        self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1))
        self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1))
        vxlan_ids.add(vxlan_id)

        for vxlan_id in vxlan_ids:
            n1kv_db_v2.release_vxlan(self.session, vxlan_id, VXLAN_RANGES)
        n1kv_db_v2.delete_network_profile(self.session, profile.id)

def _create_test_network_profile_if_not_there(session,
                                              profile=TEST_NETWORK_PROFILE):
    try:
        _profile = session.query(n1kv_models_v2.NetworkProfile).filter_by(
            name=profile['name']).one()
    except s_exc.NoResultFound:
        _profile = n1kv_db_v2.create_network_profile(session, profile)
    return _profile

 def test_get_network_profiles(self):
     test_profiles = [
         {"name": "test_profile1", "segment_type": "vlan", "physical_network": "phys1", "segment_range": "200-210"},
         {"name": "test_profile2", "segment_type": "vlan", "physical_network": "phys1", "segment_range": "211-220"},
         {"name": "test_profile3", "segment_type": "vlan", "physical_network": "phys1", "segment_range": "221-230"},
         {"name": "test_profile4", "segment_type": "vlan", "physical_network": "phys1", "segment_range": "231-240"},
         {"name": "test_profile5", "segment_type": "vlan", "physical_network": "phys1", "segment_range": "241-250"},
         {"name": "test_profile6", "segment_type": "vlan", "physical_network": "phys1", "segment_range": "251-260"},
         {"name": "test_profile7", "segment_type": "vlan", "physical_network": "phys1", "segment_range": "261-270"},
     ]
     [n1kv_db_v2.create_network_profile(self.session, p) for p in test_profiles]
     # TODO(abhraut): Fix this test to work with real tenant_td
     profiles = n1kv_db_v2._get_network_profiles(db_session=self.session)
     self.assertEqual(len(test_profiles), len(list(profiles)))

 def test_create_network_profile(self):
     _db_profile = n1kv_db_v2.create_network_profile(self.session, TEST_NETWORK_PROFILE)
     self.assertIsNotNone(_db_profile)
     db_profile = (
         self.session.query(n1kv_models_v2.NetworkProfile).filter_by(name=TEST_NETWORK_PROFILE["name"]).one()
     )
     self.assertIsNotNone(db_profile)
     self.assertEqual(_db_profile.id, db_profile.id)
     self.assertEqual(_db_profile.name, db_profile.name)
     self.assertEqual(_db_profile.segment_type, db_profile.segment_type)
     self.assertEqual(_db_profile.segment_range, db_profile.segment_range)
     self.assertEqual(_db_profile.multicast_ip_index, db_profile.multicast_ip_index)
     self.assertEqual(_db_profile.multicast_ip_range, db_profile.multicast_ip_range)
     n1kv_db_v2.delete_network_profile(self.session, _db_profile.id)

    def test_delete_network_profile(self):
        try:
            profile = (
                self.session.query(n1kv_models_v2.NetworkProfile).filter_by(name=TEST_NETWORK_PROFILE["name"]).one()
            )
        except s_exc.NoResultFound:
            profile = n1kv_db_v2.create_network_profile(self.session, TEST_NETWORK_PROFILE)

        n1kv_db_v2.delete_network_profile(self.session, profile.id)
        try:
            self.session.query(n1kv_models_v2.NetworkProfile).filter_by(name=TEST_NETWORK_PROFILE["name"]).one()
        except s_exc.NoResultFound:
            pass
        else:
            self.fail("Network Profile (%s) was not deleted" % TEST_NETWORK_PROFILE["name"])

    def _make_test_profile(self,
                           name='default_network_profile',
                           segment_range='386-400'):
        """
        Create a profile record for testing purposes.

        :param name: string representing the name of the network profile to
                     create. Default argument value chosen to correspond to the
                     default name specified in config.py file.
        :param segment_range: string representing the segment range for network
                              profile.
        """
        db_session = db.get_session()
        profile = {'name': name,
                   'segment_type': 'vlan',
                   'physical_network': PHYS_NET,
                   'tenant_id': self.tenant_id,
                   'segment_range': segment_range}
        net_p = n1kv_db_v2.create_network_profile(db_session, profile)
        n1kv_db_v2.sync_vlan_allocations(db_session, net_p)
        return net_p

    def _make_test_profile(self, name="default_network_profile", segment_range="386-400"):
        """
        Create a profile record for testing purposes.

        :param name: string representing the name of the network profile to
                     create. Default argument value chosen to correspond to the
                     default name specified in config.py file.
        :param segment_range: string representing the segment range for network
                              profile.
        """
        db_session = db.get_session()
        profile = {
            "name": name,
            "segment_type": "vlan",
            "physical_network": PHYS_NET,
            "tenant_id": self.tenant_id,
            "segment_range": segment_range,
        }
        net_p = n1kv_db_v2.create_network_profile(db_session, profile)
        n1kv_db_v2.sync_vlan_allocations(db_session, net_p)
        return net_p