← Back to branch summary

~danwent/nova/qmanager

« back to all changes in this revision

Viewing changes to nova/network/manager.py

  • Committer: Dan Wendlandt
  • Date: 2011-08-23 03:31:24 UTC
  • mfrom: (1343.1.133 nova)
  • Revision ID: dan@nicira.com-20110823033124-mgfx108h423trjmy
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/network/manager.py
131
131
        green_pool = greenpool.GreenPool()
132
132
 
133
133
        vpn = kwargs.pop('vpn')
 
134
        requested_networks = kwargs.pop('requested_networks')
 
135
 
134
136
        for network in networks:
 
137
            address = None
 
138
            if requested_networks is not None:
 
139
                for address in (fixed_ip for (uuid, fixed_ip) in \
 
140
                              requested_networks if network['uuid'] == uuid):
 
141
                    break
 
142
 
135
143
            # NOTE(vish): if we are not multi_host pass to the network host
136
144
            if not network['multi_host']:
137
145
                host = network['host']
148
156
                args = {}
149
157
                args['instance_id'] = instance_id
150
158
                args['network_id'] = network['id']
 
159
                args['address'] = address
151
160
                args['vpn'] = vpn
152
161
 
153
162
                green_pool.spawn_n(rpc.call, context, topic,
155
164
                                    'args': args})
156
165
            else:
157
166
                # i am the correct host, run here
158
 
                self.allocate_fixed_ip(context, instance_id, network, vpn=vpn)
 
167
                self.allocate_fixed_ip(context, instance_id, network,
 
168
                                       vpn=vpn, address=address)
159
169
 
160
170
        # wait for all of the allocates (if any) to finish
161
171
        green_pool.waitall()
199
209
        """
200
210
        instance_id = kwargs.get('instance_id')
201
211
        project_id = kwargs.get('project_id')
 
212
        requested_networks = kwargs.get('requested_networks')
202
213
        LOG.debug(_("floating IP allocation for instance |%s|"), instance_id,
203
214
                                                               context=context)
204
215
        # call the next inherited class's allocate_for_instance()
380
391
        self.compute_api.trigger_security_group_members_refresh(admin_context,
381
392
                                                                    group_ids)
382
393
 
383
 
    def _get_networks_for_instance(self, context, instance_id, project_id):
 
394
    def _get_networks_for_instance(self, context, instance_id, project_id,
 
395
                                   requested_networks=None):
384
396
        """Determine & return which networks an instance should connect to."""
385
397
        # TODO(tr3buchet) maybe this needs to be updated in the future if
386
398
        #                 there is a better way to determine which networks
387
399
        #                 a non-vlan instance should connect to
388
 
        try:
389
 
            networks = self.db.network_get_all(context)
390
 
        except exception.NoNetworksFound:
391
 
            return []
392
 
 
 
400
        if requested_networks is not None and len(requested_networks) != 0:
 
401
            network_uuids = [uuid for (uuid, fixed_ip) in requested_networks]
 
402
            networks = self.db.network_get_all_by_uuids(context,
 
403
                                                    network_uuids)
 
404
        else:
 
405
            try:
 
406
                networks = self.db.network_get_all(context)
 
407
            except exception.NoNetworksFound:
 
408
                return []
393
409
        # return only networks which are not vlan networks
394
410
        return [network for network in networks if
395
411
                not network['vlan']]
403
419
        host = kwargs.pop('host')
404
420
        project_id = kwargs.pop('project_id')
405
421
        type_id = kwargs.pop('instance_type_id')
 
422
        requested_networks = kwargs.get('requested_networks')
406
423
        vpn = kwargs.pop('vpn')
407
424
        admin_context = context.elevated()
408
425
        LOG.debug(_("network allocations for instance %s"), instance_id,
409
426
                                                            context=context)
410
 
        networks = self._get_networks_for_instance(admin_context, instance_id,
411
 
                                                                  project_id)
412
 
        LOG.warn(networks)
 
427
        networks = self._get_networks_for_instance(admin_context,
 
428
                                        instance_id, project_id,
 
429
                                        requested_networks=requested_networks)
413
430
        self._allocate_mac_addresses(context, instance_id, networks)
414
 
        self._allocate_fixed_ips(admin_context, instance_id, host, networks,
415
 
                                 vpn=vpn)
 
431
        self._allocate_fixed_ips(admin_context, instance_id,
 
432
                                 host, networks, vpn=vpn,
 
433
                                 requested_networks=requested_networks)
416
434
        return self.get_instance_nw_info(context, instance_id, type_id, host)
417
435
 
418
436
    def deallocate_for_instance(self, context, **kwargs):
572
590
        #             network_get_by_compute_host
573
591
        address = None
574
592
        if network['cidr']:
575
 
            address = self.db.fixed_ip_associate_pool(context.elevated(),
576
 
                                                      network['id'],
577
 
                                                      instance_id)
 
593
            address = kwargs.get('address', None)
 
594
            if address:
 
595
                address = self.db.fixed_ip_associate(context,
 
596
                                                     address, instance_id,
 
597
                                                     network['id'])
 
598
            else:
 
599
                address = self.db.fixed_ip_associate_pool(context.elevated(),
 
600
                                                          network['id'],
 
601
                                                          instance_id)
578
602
            self._do_trigger_security_group_members_refresh_for_instance(
579
603
                                                                   instance_id)
580
604
            get_vif = self.db.virtual_interface_get_by_instance_and_network
811
835
        """Sets up network on this host."""
812
836
        raise NotImplementedError()
813
837
 
 
838
    def validate_networks(self, context, networks):
 
839
        """check if the networks exists and host
 
840
        is set to each network.
 
841
        """
 
842
        if networks is None or len(networks) == 0:
 
843
            return
 
844
 
 
845
        network_uuids = [uuid for (uuid, fixed_ip) in networks]
 
846
 
 
847
        self._get_networks_by_uuids(context, network_uuids)
 
848
 
 
849
        for network_uuid, address in networks:
 
850
            # check if the fixed IP address is valid and
 
851
            # it actually belongs to the network
 
852
            if address is not None:
 
853
                if not utils.is_valid_ipv4(address):
 
854
                    raise exception.FixedIpInvalid(address=address)
 
855
 
 
856
                fixed_ip_ref = self.db.fixed_ip_get_by_address(context,
 
857
                                                               address)
 
858
                if fixed_ip_ref['network']['uuid'] != network_uuid:
 
859
                    raise exception.FixedIpNotFoundForNetwork(address=address,
 
860
                                            network_uuid=network_uuid)
 
861
                if fixed_ip_ref['instance'] is not None:
 
862
                    raise exception.FixedIpAlreadyInUse(address=address)
 
863
 
 
864
    def _get_networks_by_uuids(self, context, network_uuids):
 
865
        return self.db.network_get_all_by_uuids(context, network_uuids)
 
866
 
814
867
 
815
868
class FlatManager(NetworkManager):
816
869
    """Basic network where no vlans are used.
845
898
    def _allocate_fixed_ips(self, context, instance_id, host, networks,
846
899
                            **kwargs):
847
900
        """Calls allocate_fixed_ip once for each network."""
 
901
        requested_networks = kwargs.pop('requested_networks')
848
902
        for network in networks:
849
 
            self.allocate_fixed_ip(context, instance_id, network)
 
903
            address = None
 
904
            if requested_networks is not None:
 
905
                for address in (fixed_ip for (uuid, fixed_ip) in \
 
906
                              requested_networks if network['uuid'] == uuid):
 
907
                    break
 
908
 
 
909
            self.allocate_fixed_ip(context, instance_id,
 
910
                                   network, address=address)
850
911
 
851
912
    def deallocate_fixed_ip(self, context, address, **kwargs):
852
913
        """Returns a fixed ip to the pool."""
940
1001
                                       address,
941
1002
                                       instance_id)
942
1003
        else:
943
 
            address = self.db.fixed_ip_associate_pool(context,
944
 
                                                      network['id'],
945
 
                                                      instance_id)
 
1004
            address = kwargs.get('address', None)
 
1005
            if address:
 
1006
                address = self.db.fixed_ip_associate(context, address,
 
1007
                                                     instance_id,
 
1008
                                                     network['id'])
 
1009
            else:
 
1010
                address = self.db.fixed_ip_associate_pool(context,
 
1011
                                                          network['id'],
 
1012
                                                          instance_id)
946
1013
            self._do_trigger_security_group_members_refresh_for_instance(
947
1014
                                                                   instance_id)
948
1015
        vif = self.db.virtual_interface_get_by_instance_and_network(context,
958
1025
        """Force adds another network to a project."""
959
1026
        self.db.network_associate(context, project_id, force=True)
960
1027
 
961
 
    def _get_networks_for_instance(self, context, instance_id, project_id):
 
1028
    def _get_networks_for_instance(self, context, instance_id, project_id,
 
1029
                                   requested_networks=None):
962
1030
        """Determine which networks an instance should connect to."""
963
1031
        # get networks associated with project
964
 
        return self.db.project_get_networks(context, project_id)
 
1032
        if requested_networks is not None and len(requested_networks) != 0:
 
1033
            network_uuids = [uuid for (uuid, fixed_ip) in requested_networks]
 
1034
            networks = self.db.network_get_all_by_uuids(context,
 
1035
                                                    network_uuids,
 
1036
                                                    project_id)
 
1037
        else:
 
1038
            networks = self.db.project_get_networks(context, project_id)
 
1039
        return networks
965
1040
 
966
1041
    def create_networks(self, context, **kwargs):
967
1042
        """Create networks based on parameters."""
1010
1085
                self.db.network_update(context, network_ref['id'],
1011
1086
                                       {'gateway_v6': gateway})
1012
1087
 
 
1088
    def _get_networks_by_uuids(self, context, network_uuids):
 
1089
        return self.db.network_get_all_by_uuids(context, network_uuids,
 
1090
                                                     context.project_id)
 
1091
 
1013
1092
    @property
1014
1093
    def _bottom_reserved_ips(self):
1015
1094
        """Number of reserved ips at the bottom of the range."""