Python db.get_network_segments函数代码示例

 def sync_highperformance_routers(self, context, **kwargs):
     routers = self.sync_routers(context, **kwargs)
     for router in routers:
         for snat_port in router.get(constants.SNAT_ROUTER_INTF_KEY, []):
             network_segments = ml2_db.get_network_segments(context.session, 
                                                            snat_port['network_id'])
             if network_segments:
                 snat_port['vni'] = network_segments[0][api.SEGMENTATION_ID]
         gw_port = router.get('gw_port')
         if gw_port:
             network_segments = ml2_db.get_network_segments(context.session, 
                                                            gw_port['network_id'])
             if network_segments:
                 gw_port['vlan'] = network_segments[0][api.SEGMENTATION_ID]
     
     return routers

    def test_release_network_segments(self):
        data = {
            "network": {
                "name": "net1",
                "admin_state_up": True,
                "shared": False,
                pnet.NETWORK_TYPE: "vlan",
                pnet.PHYSICAL_NETWORK: "physnet1",
                pnet.SEGMENTATION_ID: 1,
                "tenant_id": "tenant_one",
            }
        }
        network_req = self.new_create_request("networks", data)
        res = network_req.get_response(self.api)
        network = self.deserialize(self.fmt, res)
        network_id = network["network"]["id"]
        segment = {driver_api.NETWORK_TYPE: "vlan", driver_api.PHYSICAL_NETWORK: "physnet2"}
        self.driver.type_manager.allocate_dynamic_segment(self.context.session, network_id, segment)
        dynamic_segment = ml2_db.get_dynamic_segment(self.context.session, network_id, "physnet2")
        self.assertEqual("vlan", dynamic_segment[driver_api.NETWORK_TYPE])
        self.assertEqual("physnet2", dynamic_segment[driver_api.PHYSICAL_NETWORK])
        self.assertTrue(dynamic_segment[driver_api.SEGMENTATION_ID] > 0)

        with mock.patch.object(type_vlan.VlanTypeDriver, "release_segment") as rs:
            req = self.new_delete_request("networks", network_id)
            res = req.get_response(self.api)
            self.assertEqual(2, rs.call_count)
        self.assertEqual(ml2_db.get_network_segments(self.context.session, network_id), [])
        self.assertIsNone(ml2_db.get_dynamic_segment(self.context.session, network_id, "physnet2"))

    def _extend_network_dict_provider(self, context, network):
        if 'id' not in network:
            LOG.debug("Network has no id")
            network[provider.NETWORK_TYPE] = None
            network[provider.PHYSICAL_NETWORK] = None
            network[provider.SEGMENTATION_ID] = None
            return

        net_id = network['id']
        segments = db_ml2.get_network_segments(
            context.session, net_id, filter_dynamic=True)

        if not segments:
            LOG.debug("Network %s has no segments", net_id)
            network[provider.NETWORK_TYPE] = None
            network[provider.PHYSICAL_NETWORK] = None
            network[provider.SEGMENTATION_ID] = None
        elif len(segments) > 1:
            network[mpnet.SEGMENTS] = [
                {provider.NETWORK_TYPE: segment[api.NETWORK_TYPE],
                 provider.PHYSICAL_NETWORK: segment[api.PHYSICAL_NETWORK],
                 provider.SEGMENTATION_ID: segment[api.SEGMENTATION_ID]}
                for segment in segments]
        else:
            segment = segments[0]
            network[provider.NETWORK_TYPE] = segment[api.NETWORK_TYPE]
            network[provider.PHYSICAL_NETWORK] = segment[api.PHYSICAL_NETWORK]
            network[provider.SEGMENTATION_ID] = segment[api.SEGMENTATION_ID]

    def test_release_network_segments(self):
        data = {'network': {'name': 'net1',
                            'admin_state_up': True,
                            'shared': False,
                            pnet.NETWORK_TYPE: 'vlan',
                            pnet.PHYSICAL_NETWORK: 'physnet1',
                            pnet.SEGMENTATION_ID: 1,
                            'tenant_id': 'tenant_one'}}
        network_req = self.new_create_request('networks', data)
        res = network_req.get_response(self.api)
        network = self.deserialize(self.fmt, res)
        network_id = network['network']['id']
        segment = {driver_api.NETWORK_TYPE: 'vlan',
                   driver_api.PHYSICAL_NETWORK: 'physnet2'}
        self.driver.type_manager.allocate_dynamic_segment(
            self.context.session, network_id, segment)
        dynamic_segment = ml2_db.get_dynamic_segment(self.context.session,
                                                     network_id,
                                                     'physnet2')
        self.assertEqual('vlan', dynamic_segment[driver_api.NETWORK_TYPE])
        self.assertEqual('physnet2',
                         dynamic_segment[driver_api.PHYSICAL_NETWORK])
        self.assertTrue(dynamic_segment[driver_api.SEGMENTATION_ID] > 0)

        with mock.patch.object(type_vlan.VlanTypeDriver,
                               'release_segment') as rs:
            req = self.new_delete_request('networks', network_id)
            res = req.get_response(self.api)
            self.assertEqual(2, rs.call_count)
        self.assertEqual(ml2_db.get_network_segments(
            self.context.session, network_id), [])
        self.assertIsNone(ml2_db.get_dynamic_segment(
            self.context.session, network_id, 'physnet2'))

 def __init__(self, plugin, plugin_context, network,
              original_network=None):
     super(NetworkContext, self).__init__(plugin, plugin_context)
     self._network = network
     self._original_network = original_network
     self._segments = db.get_network_segments(plugin_context.session,
                                              network['id'])

    def get_network_segid(self, sid):
        """Get network segmentation id.

        :param sid: requested segment id
        """
        db_session = db.get_session()
        seg_entry = ml2db.get_network_segments(db_session, sid)
        return seg_entry[0]['segmentation_id']

 def get_shared_network_owner_id(self, network_id):
     filters = {'id': [network_id]}
     nets = self.get_networks(self.admin_ctx, filters=filters) or []
     segments = ml2_db.get_network_segments(self.admin_ctx.session,
                                            network_id)
     if not nets or not segments:
         return
     if (nets[0]['shared'] and
        segments[0][driver_api.NETWORK_TYPE] == p_const.TYPE_VLAN):
         return nets[0]['tenant_id']

    def release_network_segments(self, session, network_id):
        segments = db.get_network_segments(session, network_id, filter_dynamic=None)

        for segment in segments:
            network_type = segment.get(api.NETWORK_TYPE)
            driver = self.drivers.get(network_type)
            if driver:
                driver.obj.release_segment(session, segment)
            else:
                LOG.error(_LE("Failed to release segment '%s' because " "network type is not supported."), segment)

    def delete_network(self, context, id):
        session = context.session
        with session.begin(subtransactions=True):
            segments = db.get_network_segments(session, id)
            super(Ml2Plugin, self).delete_network(context, id)
            for segment in segments:
                self.type_manager.release_segment(session, segment)
            # The segment records are deleted via cascade from the
            # network record, so explicit removal is not necessary.

        self.notifier.network_delete(context, id)

    def _create_segments(self, segments, is_seg_dynamic=False, network_id="foo-network-id"):
        self._setup_neutron_network(network_id)
        for segment in segments:
            ml2_db.add_network_segment(self.ctx.session, network_id, segment, is_dynamic=is_seg_dynamic)

        net_segments = ml2_db.get_network_segments(self.ctx.session, network_id, filter_dynamic=is_seg_dynamic)

        for segment_index, segment in enumerate(segments):
            self.assertEqual(segment, net_segments[segment_index])

        return net_segments

def get_vlan_id_of_physical_network(context, network_id, physical_network):
    if hasattr(context, 'session'):
        session = context.session
    else:
        session = context.network._plugin_context.session
    segments = db_ml2.get_network_segments(session, network_id)
    if not segments:
        return ''
    for segment in segments:
        if segment[api.PHYSICAL_NETWORK] == physical_network:
            return str(segment[api.SEGMENTATION_ID])
    return str(segments[0][api.SEGMENTATION_ID])

 def _log_subnet_information(self, method_name, current_context, prev_context):
     driver_logger.info("**** %s ****" % (method_name))
     driver_logger.info("Current Subnet Name: %s" % (current_context['name']))
     driver_logger.info("Current Subnet CIDR: %s" % (current_context['cidr']))
     # Extract the Network ID from the Subnet Context
     network_id = current_context['network_id']
     # Get the Neutron DB Session Handle
     session = db.get_session()
     # Using ML2 DB API, fetch the Network that matches the Network ID
     networks = ml2_db.get_network_segments(session, network_id)
     driver_logger.info("Network associated to the Subnet: %s" % (networks))
     driver_logger.info("**** %s ****" % (method_name))

 def _notify_port_updated(self, context, port):
     session = context.session
     with session.begin(subtransactions=True):
         network_id = port['network_id']
         segments = db.get_network_segments(session, network_id)
         if not segments:
             LOG.warning(_("In _notify_port_updated() for port %(port_id), "
                           "network %(network_id) has no segments"),
                         {'port_id': port['id'],
                          'network_id': network_id})
             return
         # TODO(rkukura): Use port binding to select segment.
         segment = segments[0]
     self.notifier.port_update(context, port,
                               segment[api.NETWORK_TYPE],
                               segment[api.SEGMENTATION_ID],
                               segment[api.PHYSICAL_NETWORK])

 def _extend_network_dict_provider(self, context, network):
     id = network['id']
     segments = db.get_network_segments(context.session, id)
     if not segments:
         LOG.error(_("Network %s has no segments"), id)
         network[provider.NETWORK_TYPE] = None
         network[provider.PHYSICAL_NETWORK] = None
         network[provider.SEGMENTATION_ID] = None
     elif len(segments) > 1:
         network[provider.NETWORK_TYPE] = TYPE_MULTI_SEGMENT
         network[provider.PHYSICAL_NETWORK] = None
         network[provider.SEGMENTATION_ID] = None
     else:
         segment = segments[0]
         network[provider.NETWORK_TYPE] = segment[api.NETWORK_TYPE]
         network[provider.PHYSICAL_NETWORK] = segment[api.PHYSICAL_NETWORK]
         network[provider.SEGMENTATION_ID] = segment[api.SEGMENTATION_ID]

 def extend_network_dict_provider(self, context, network):
     id = network['id']
     segments = db.get_network_segments(context.session, id)
     if not segments:
         LOG.error(_LE("Network %s has no segments"), id)
         for attr in provider.ATTRIBUTES:
             network[attr] = None
     elif len(segments) > 1:
         network[mpnet.SEGMENTS] = [
             {provider.NETWORK_TYPE: segment[api.NETWORK_TYPE],
              provider.PHYSICAL_NETWORK: segment[api.PHYSICAL_NETWORK],
              provider.SEGMENTATION_ID: segment[api.SEGMENTATION_ID]}
             for segment in segments]
     else:
         segment = segments[0]
         network[provider.NETWORK_TYPE] = segment[api.NETWORK_TYPE]
         network[provider.PHYSICAL_NETWORK] = segment[api.PHYSICAL_NETWORK]
         network[provider.SEGMENTATION_ID] = segment[api.SEGMENTATION_ID]