From 2a6f97940f71c056b4bfb0cd9a86f5d676abc4e1 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Mon, 11 Jul 2011 13:34:39 -0700 Subject: add optional parameter networks to the Create server OS API --- nova/api/openstack/create_instance_helper.py | 55 +++++++++++- nova/compute/api.py | 34 ++++++-- nova/compute/manager.py | 4 +- nova/db/api.py | 32 +++++++ nova/db/sqlalchemy/api.py | 125 ++++++++++++++++++++++++++- nova/exception.py | 26 ++++++ nova/network/api.py | 9 ++ nova/network/manager.py | 125 ++++++++++++++++++++++----- nova/utils.py | 16 ++++ 9 files changed, 390 insertions(+), 36 deletions(-) (limited to 'nova') diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 1066713a3..839aa9fb9 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -32,7 +32,6 @@ from nova.api.openstack import faults from nova.api.openstack import wsgi from nova.auth import manager as auth_manager - LOG = logging.getLogger('nova.api.openstack.create_instance_helper') FLAGS = flags.FLAGS @@ -102,6 +101,15 @@ class CreateInstanceHelper(object): if personality: injected_files = self._get_injected_files(personality) + requested_networks = body['server'].get('networks') + + if requested_networks is not None: + if len(requested_networks) == 0: + msg = _("No networks found") + raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) + requested_networks = self._get_requested_networks( + requested_networks) + flavor_id = self.controller._flavor_id_from_req_data(body) if not 'name' in body['server']: @@ -148,12 +156,17 @@ class CreateInstanceHelper(object): zone_blob=zone_blob, reservation_id=reservation_id, min_count=min_count, - max_count=max_count)) + max_count=max_count, + requested_networks=requested_networks)) except quota.QuotaError as error: self._handle_quota_error(error) except exception.ImageNotFound as error: msg = _("Can not find requested image") raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) + except exception.NovaException as ex: + LOG.error(ex) + msg = _("Failed to create server: %s") % ex + raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) # Let the caller deal with unhandled exceptions. @@ -276,6 +289,44 @@ class CreateInstanceHelper(object): raise exc.HTTPBadRequest(explanation=msg) return password + def _get_requested_networks(self, requested_networks): + """ + Create a list of requested networks from the networks attribute + """ + networks = [] + for network in requested_networks: + try: + network_id = network['id'] + network_id = int(network_id) + #fixed IP address is optional + #if the fixed IP address is not provided then + #it will used one of the available IP address from the network + fixed_ip = network.get('fixed_ip', None) + + # check if the network id is already present in the list, + # we don't want duplicate networks to be passed + # at the boot time + for id, ip in networks: + if id == network_id: + expl = _("Duplicate networks (%s) are not allowed")\ + % network_id + raise faults.Fault(exc.HTTPBadRequest( + explanation=expl)) + + networks.append((network_id, fixed_ip)) + except KeyError as key: + expl = _('Bad network format: missing %s') % key + raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) + except ValueError: + expl = _("Bad networks format: network id should " + "be integer (%s)") % network_id + raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) + except TypeError: + expl = _('Bad networks format') + raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) + + return networks + class ServerXMLDeserializer(wsgi.XMLDeserializer): """ diff --git a/nova/compute/api.py b/nova/compute/api.py index 28459dc75..273ff285d 100644 --- a/nova/compute/api.py +++ b/nova/compute/api.py @@ -95,6 +95,7 @@ class API(base.Base): if not network_api: network_api = network.API() self.network_api = network_api + self.network_manager = utils.import_object(FLAGS.network_manager) if not volume_api: volume_api = volume.API() self.volume_api = volume_api @@ -142,6 +143,16 @@ class API(base.Base): LOG.warn(msg) raise quota.QuotaError(msg, "MetadataLimitExceeded") + def _check_requested_networks(self, context, requested_networks): + """ Check if the networks requested belongs to the project + and the fixed IP address for each network provided is within + same the network block + """ + if requested_networks is None: + return + + self.network_api.validate_networks(context, requested_networks) + def _check_create_parameters(self, context, instance_type, image_href, kernel_id=None, ramdisk_id=None, min_count=None, max_count=None, @@ -149,7 +160,7 @@ class API(base.Base): key_name=None, key_data=None, security_group='default', availability_zone=None, user_data=None, metadata={}, injected_files=None, admin_password=None, zone_blob=None, - reservation_id=None): + reservation_id=None, requested_networks=None): """Verify all the input parameters regardless of the provisioning strategy being performed.""" @@ -176,6 +187,7 @@ class API(base.Base): self._check_metadata_properties_quota(context, metadata) self._check_injected_file_quota(context, injected_files) + self._check_requested_networks(context, requested_networks) (image_service, image_id) = nova.image.get_image_service(image_href) image = image_service.show(context, image_id) @@ -315,7 +327,8 @@ class API(base.Base): instance_type, zone_blob, availability_zone, injected_files, admin_password, - instance_id=None, num_instances=1): + instance_id=None, num_instances=1, + requested_networks=None): """Send the run_instance request to the schedulers for processing.""" pid = context.project_id uid = context.user_id @@ -343,7 +356,8 @@ class API(base.Base): "request_spec": request_spec, "availability_zone": availability_zone, "admin_password": admin_password, - "injected_files": injected_files}}) + "injected_files": injected_files, + "requested_networks": requested_networks}}) def create_all_at_once(self, context, instance_type, image_href, kernel_id=None, ramdisk_id=None, @@ -381,7 +395,8 @@ class API(base.Base): key_name=None, key_data=None, security_group='default', availability_zone=None, user_data=None, metadata={}, injected_files=None, admin_password=None, zone_blob=None, - reservation_id=None, block_device_mapping=None): + reservation_id=None, block_device_mapping=None, + requested_networks=None): """ Provision the instances by sending off a series of single instance requests to the Schedulers. This is fine for trival @@ -402,7 +417,7 @@ class API(base.Base): key_name, key_data, security_group, availability_zone, user_data, metadata, injected_files, admin_password, zone_blob, - reservation_id) + reservation_id, requested_networks) instances = [] LOG.debug(_("Going to run %s instances..."), num_instances) @@ -414,10 +429,11 @@ class API(base.Base): instance_id = instance['id'] self._ask_scheduler_to_create_instance(context, base_options, - instance_type, zone_blob, - availability_zone, injected_files, - admin_password, - instance_id=instance_id) + instance_type, zone_blob, + availability_zone, injected_files, + admin_password, + instance_id=instance_id, + requested_networks=requested_networks) return [dict(x.iteritems()) for x in instances] diff --git a/nova/compute/manager.py b/nova/compute/manager.py index bbbddde0a..f77728034 100644 --- a/nova/compute/manager.py +++ b/nova/compute/manager.py @@ -269,6 +269,7 @@ class ComputeManager(manager.SchedulerDependentManager): context = context.elevated() instance = self.db.instance_get(context, instance_id) instance.injected_files = kwargs.get('injected_files', []) + requested_networks = kwargs.get('requested_networks', None) instance.admin_pass = kwargs.get('admin_password', None) if instance['name'] in self.driver.list_instances(): raise exception.Error(_("Instance has already been created")) @@ -291,7 +292,8 @@ class ComputeManager(manager.SchedulerDependentManager): # will eventually also need to save the address here. if not FLAGS.stub_network: network_info = self.network_api.allocate_for_instance(context, - instance, vpn=is_vpn) + instance, vpn=is_vpn, + requested_networks=requested_networks) LOG.debug(_("instance network_info: |%s|"), network_info) self.network_manager.setup_compute_network(context, instance_id) diff --git a/nova/db/api.py b/nova/db/api.py index b7c5700e5..ca904738d 100644 --- a/nova/db/api.py +++ b/nova/db/api.py @@ -341,6 +341,14 @@ def fixed_ip_associate_pool(context, network_id, instance_id): return IMPL.fixed_ip_associate_pool(context, network_id, instance_id) +def fixed_ip_associate_by_address(context, network_id, instance_id, address): + """check if the address is free and is in the network + and it is not associated to any instance. + """ + return IMPL.fixed_ip_associate_by_address(context, network_id, + instance_id, address) + + def fixed_ip_create(context, values): """Create a fixed ip from the values dictionary.""" return IMPL.fixed_ip_create(context, values) @@ -400,6 +408,13 @@ def fixed_ip_update(context, address, values): return IMPL.fixed_ip_update(context, address, values) +def fixed_ip_validate_by_network_address(context, network_id, + address): + """validates if the address belongs to the network""" + return IMPL.fixed_ip_validate_by_network_address(context, network_id, + address) + + #################### @@ -689,7 +704,14 @@ def network_get_all(context): return IMPL.network_get_all(context) +def network_get_requested_networks(context, requested_networks): + """Return all defined networks.""" + return IMPL.network_get_requested_networks(context, requested_networks) + + # pylint: disable=C0103 + + def network_get_associated_fixed_ips(context, network_id): """Get all network's ips that have been associated.""" return IMPL.network_get_associated_fixed_ips(context, network_id) @@ -1228,6 +1250,16 @@ def project_get_networks(context, project_id, associate=True): return IMPL.project_get_networks(context, project_id, associate) +def project_get_requested_networks(context, requested_networks): + """Return the network associated with the project. + + If associate is true, it will attempt to associate a new + network if one is not found, otherwise it returns None. + + """ + return IMPL.project_get_requested_networks(context, requested_networks) + + def project_get_networks_v6(context, project_id): return IMPL.project_get_networks_v6(context, project_id) diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py index ffd009513..d5cfc6099 100644 --- a/nova/db/sqlalchemy/api.py +++ b/nova/db/sqlalchemy/api.py @@ -251,7 +251,7 @@ def service_get_all_network_sorted(context): session = get_session() with session.begin(): topic = 'network' - label = 'network_count' + label = 'network_' subq = session.query(models.Network.host, func.count(models.Network.id).label(label)).\ filter_by(deleted=False).\ @@ -684,6 +684,40 @@ def fixed_ip_associate_pool(context, network_id, instance_id): return fixed_ip_ref['address'] +@require_admin_context +def fixed_ip_associate_by_address(context, network_id, instance_id, + address): + if address is None: + return fixed_ip_associate_pool(context, network_id, instance_id) + + session = get_session() + with session.begin(): + fixed_ip_ref = session.query(models.FixedIp).\ + filter_by(reserved=False).\ + filter_by(deleted=False).\ + filter_by(network_id=network_id).\ + filter_by(address=address).\ + with_lockmode('update').\ + first() + # NOTE(vish): if with_lockmode isn't supported, as in sqlite, + # then this has concurrency issues + if fixed_ip_ref is None: + raise exception.FixedIpNotFoundForNetwork(address=address, + network_id=network_id) + if fixed_ip_ref.instance is not None: + raise exception.FixedIpAlreadyInUse(address=address) + + if not fixed_ip_ref.network: + fixed_ip_ref.network = network_get(context, + network_id, + session=session) + fixed_ip_ref.instance = instance_get(context, + instance_id, + session=session) + session.add(fixed_ip_ref) + return fixed_ip_ref['address'] + + @require_context def fixed_ip_create(_context, values): fixed_ip_ref = models.FixedIp() @@ -771,6 +805,26 @@ def fixed_ip_get_by_address(context, address, session=None): return result +@require_context +def fixed_ip_validate_by_network_address(context, network_id, + address): + session = get_session() + fixed_ip_ref = session.query(models.FixedIp).\ + filter_by(address=address).\ + filter_by(reserved=False).\ + filter_by(network_id=network_id).\ + filter_by(deleted=can_read_deleted(context)).\ + first() + + if fixed_ip_ref is None: + raise exception.FixedIpNotFoundForNetwork(address=address, + network_id=network_id) + if fixed_ip_ref.instance is not None: + raise exception.FixedIpAlreadyInUse(address=address) + + return fixed_ip_ref + + @require_context def fixed_ip_get_by_instance(context, instance_id): session = get_session() @@ -1613,6 +1667,39 @@ def network_get_all(context): return result +@require_admin_context +def network_get_requested_networks(context, requested_networks): + session = get_session() + + network_ids = [] + for id, fixed_ip in requested_networks: + network_ids.append(id) + + result = session.query(models.Network).\ + filter(models.Network.id.in_(network_ids)).\ + filter_by(deleted=False).all() + if not result: + raise exception.NoNetworksFound() + + #check if host is set to all of the networks + # returned in the result + for network in result: + if network['host'] is None: + raise exception.NetworkHostNotSet(network_id=network['id']) + + #check if the result contains all the networks + #we are looking for + for network_id in network_ids: + found = False + for network in result: + if network['id'] == network_id: + found = True + break + if not found: + raise exception.NetworkNotFound(network_id=network_id) + + return result + # NOTE(vish): pylint complains because of the long method name, but # it fits with the names of the rest of the methods # pylint: disable=C0103 @@ -2727,6 +2814,42 @@ def project_get_networks(context, project_id, associate=True): return result +@require_context +def project_get_requested_networks(context, requested_networks): + session = get_session() + + network_ids = [] + for id, fixed_ip in requested_networks: + network_ids.append(id) + + result = session.query(models.Network).\ + filter(models.Network.id.in_(network_ids)).\ + filter_by(deleted=False).\ + filter_by(project_id=context.project_id).all() + + if not result: + raise exception.NoNetworksFound() + + #check if host is set to all of the networks + # returned in the result + for network in result: + if network['host'] is None: + raise exception.NetworkHostNotSet(network_id=network['id']) + + #check if the result contains all the networks + #we are looking for + for network_id in network_ids: + found = False + for network in result: + if network['id'] == network_id: + found = True + break + if not found: + raise exception.NetworkNotFoundForProject(network_id=network_id, + project_id=context.project_id) + return result + + @require_context def project_get_networks_v6(context, project_id): return project_get_networks(context, project_id) diff --git a/nova/exception.py b/nova/exception.py index a6776b64f..a1803d4f6 100644 --- a/nova/exception.py +++ b/nova/exception.py @@ -142,6 +142,10 @@ class Invalid(NovaException): message = _("Unacceptable parameters.") +class AlreadyInUse(NovaException): + message = _("Already is in use.") + + class InvalidSignature(Invalid): message = _("Invalid signature %(signature)s for user %(user)s.") @@ -361,6 +365,15 @@ class NoNetworksFound(NotFound): message = _("No networks defined.") +class NetworkNotFoundForProject(NotFound): + message = _("Either Network %(network_id)s is not present or " + "is not assigned to the project %(project_id)s.") + + +class NetworkHostNotSet(NovaException): + message = _("Host is not set to the network (%(network_id)s).") + + class DatastoreNotFound(NotFound): message = _("Could not find the datastore reference(s) which the VM uses.") @@ -385,6 +398,19 @@ class FixedIpNotFoundForHost(FixedIpNotFound): message = _("Host %(host)s has zero fixed ips.") +class FixedIpNotFoundForNetwork(FixedIpNotFound): + message = _("Fixed IP address (%(address)s) does not exist in " + "network (%(network_id)s).") + + +class FixedIpAlreadyInUse(AlreadyInUse): + message = _("Fixed IP address %(address)s is already in use.") + + +class FixedIpInvalid(Invalid): + message = _("Fixed IP address %(address)s is invalid.") + + class NoMoreFixedIps(Error): message = _("Zero fixed ips available.") diff --git a/nova/network/api.py b/nova/network/api.py index b2b96082b..0993038a7 100644 --- a/nova/network/api.py +++ b/nova/network/api.py @@ -169,3 +169,12 @@ class API(base.Base): return rpc.call(context, FLAGS.network_topic, {'method': 'get_instance_nw_info', 'args': args}) + + def validate_networks(self, context, requested_networks): + """validate the networks passed at the time of creating + the server + """ + args = {'networks': requested_networks} + return rpc.call(context, FLAGS.network_topic, + {'method': 'validate_networks', + 'args': args}) diff --git a/nova/network/manager.py b/nova/network/manager.py index d42bc8c4e..746b2ecc2 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -124,11 +124,18 @@ class RPCAllocateFixedIP(object): used since they share code to RPC.call allocate_fixed_ip on the correct network host to configure dnsmasq """ - def _allocate_fixed_ips(self, context, instance_id, networks): + def _allocate_fixed_ips(self, context, instance_id, networks, + requested_networks=None): """Calls allocate_fixed_ip once for each network.""" green_pool = greenpool.GreenPool() - for network in networks: + address = None + if requested_networks is not None: + for id, fixed_ip in requested_networks: + if (network['id'] == id): + address = fixed_ip + break + if network['host'] != self.host: # need to call allocate_fixed_ip to correct network host topic = self.db.queue_get_for(context, FLAGS.network_topic, @@ -136,23 +143,25 @@ class RPCAllocateFixedIP(object): args = {} args['instance_id'] = instance_id args['network_id'] = network['id'] - + args['address'] = address green_pool.spawn_n(rpc.call, context, topic, {'method': '_rpc_allocate_fixed_ip', 'args': args}) else: # i am the correct host, run here - self.allocate_fixed_ip(context, instance_id, network) + self.allocate_fixed_ip(context, instance_id, network, + address=address) # wait for all of the allocates (if any) to finish green_pool.waitall() - def _rpc_allocate_fixed_ip(self, context, instance_id, network_id): + def _rpc_allocate_fixed_ip(self, context, instance_id, network_id, + address=None): """Sits in between _allocate_fixed_ips and allocate_fixed_ip to perform network lookup on the far side of rpc. """ network = self.db.network_get(context, network_id) - self.allocate_fixed_ip(context, instance_id, network) + self.allocate_fixed_ip(context, instance_id, network, address=address) class FloatingIP(object): @@ -185,6 +194,7 @@ class FloatingIP(object): """ instance_id = kwargs.get('instance_id') project_id = kwargs.get('project_id') + requested_networks = kwargs.get('requested_networks') LOG.debug(_("floating IP allocation for instance |%s|"), instance_id, context=context) # call the next inherited class's allocate_for_instance() @@ -339,16 +349,21 @@ class NetworkManager(manager.SchedulerDependentManager): networks = self.db.network_get_all(context) for network in networks: host = network['host'] - if not host: + if host: # return so worker will only grab 1 (to help scale flatter) return self.set_network_host(context, network['id']) - def _get_networks_for_instance(self, context, instance_id, project_id): + def _get_networks_for_instance(self, context, instance_id, project_id, + requested_networks=None): """Determine & return which networks an instance should connect to.""" # TODO(tr3buchet) maybe this needs to be updated in the future if # there is a better way to determine which networks # a non-vlan instance should connect to - networks = self.db.network_get_all(context) + if requested_networks: + networks = self.db.network_get_requested_networks(context, + requested_networks) + else: + networks = self.db.network_get_all(context) # return only networks which are not vlan networks and have host set return [network for network in networks if @@ -362,13 +377,19 @@ class NetworkManager(manager.SchedulerDependentManager): instance_id = kwargs.pop('instance_id') project_id = kwargs.pop('project_id') type_id = kwargs.pop('instance_type_id') + requested_networks = kwargs.pop('requested_networks') + LOG.debug(requested_networks) admin_context = context.elevated() LOG.debug(_("network allocations for instance %s"), instance_id, context=context) - networks = self._get_networks_for_instance(admin_context, instance_id, - project_id) + networks = self._get_networks_for_instance(admin_context, + instance_id, + project_id, + requested_networks) self._allocate_mac_addresses(context, instance_id, networks) - self._allocate_fixed_ips(admin_context, instance_id, networks) + self._allocate_fixed_ips(admin_context, instance_id, + networks, + requested_networks=requested_networks) return self.get_instance_nw_info(context, instance_id, type_id) def deallocate_for_instance(self, context, **kwargs): @@ -486,9 +507,11 @@ class NetworkManager(manager.SchedulerDependentManager): # with a network, or a cluster of computes with a network # and use that network here with a method like # network_get_by_compute_host - address = self.db.fixed_ip_associate_pool(context.elevated(), + address = kwargs.get('address', None) + address = self.db.fixed_ip_associate_by_address(context.elevated(), network['id'], - instance_id) + instance_id, + address) vif = self.db.virtual_interface_get_by_instance_and_network(context, instance_id, network['id']) @@ -637,7 +660,8 @@ class NetworkManager(manager.SchedulerDependentManager): 'address': address, 'reserved': reserved}) - def _allocate_fixed_ips(self, context, instance_id, networks): + def _allocate_fixed_ips(self, context, instance_id, networks, + requested_networks=None): """Calls allocate_fixed_ip once for each network.""" raise NotImplementedError() @@ -653,6 +677,25 @@ class NetworkManager(manager.SchedulerDependentManager): """ raise NotImplementedError() + def validate_networks(self, context, networks): + """check if the networks exists and host + is set to each network. + """ + if networks is None: + return + + result = self.db.network_get_requested_networks(context, networks) + for network_id, fixed_ip in networks: + # check if the fixed IP address is valid and + # it actually belongs to the network + if fixed_ip is not None: + if not utils.is_valid_ipv4(fixed_ip): + raise exception.FixedIpInvalid(address=fixed_ip) + + self.db.fixed_ip_validate_by_network_address(context, + network_id, + fixed_ip) + class FlatManager(NetworkManager): """Basic network where no vlans are used. @@ -684,10 +727,18 @@ class FlatManager(NetworkManager): timeout_fixed_ips = False - def _allocate_fixed_ips(self, context, instance_id, networks): + def _allocate_fixed_ips(self, context, instance_id, networks, + requested_networks=None): """Calls allocate_fixed_ip once for each network.""" for network in networks: - self.allocate_fixed_ip(context, instance_id, network) + address = None + if requested_networks is not None: + for id, fixed_ip in requested_networks: + if (network['id'] == id): + address = fixed_ip + break + self.allocate_fixed_ip(context, instance_id, + network, address=address) def deallocate_fixed_ip(self, context, address, **kwargs): """Returns a fixed ip to the pool.""" @@ -741,11 +792,13 @@ class FlatDHCPManager(FloatingIP, RPCAllocateFixedIP, NetworkManager): self.driver.ensure_bridge(network['bridge'], network['bridge_interface']) - def allocate_fixed_ip(self, context, instance_id, network): + def allocate_fixed_ip(self, context, instance_id, network, + address=None): """Allocate flat_network fixed_ip, then setup dhcp for this network.""" address = super(FlatDHCPManager, self).allocate_fixed_ip(context, instance_id, - network) + network, + address) if not FLAGS.fake_network: self.driver.update_dhcp(context, network['id']) @@ -794,15 +847,17 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): def allocate_fixed_ip(self, context, instance_id, network, **kwargs): """Gets a fixed ip from the pool.""" + address = kwargs.get('address', None) if kwargs.get('vpn', None): address = network['vpn_private_address'] self.db.fixed_ip_associate(context, address, instance_id) else: - address = self.db.fixed_ip_associate_pool(context, + address = self.db.fixed_ip_associate_by_address(context, network['id'], - instance_id) + instance_id, + address) vif = self.db.virtual_interface_get_by_instance_and_network(context, instance_id, network['id']) @@ -826,10 +881,15 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): network['bridge'], network['bridge_interface']) - def _get_networks_for_instance(self, context, instance_id, project_id): + def _get_networks_for_instance(self, context, instance_id, project_id, + requested_networks=None): """Determine which networks an instance should connect to.""" # get networks associated with project - networks = self.db.project_get_networks(context, project_id) + if requested_networks is not None: + networks = self.db.project_get_requested_networks(context, + requested_networks) + else: + networks = self.db.project_get_networks(context, project_id) # return only networks which have host set return [network for network in networks if network['host']] @@ -878,6 +938,25 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): if(FLAGS.use_ipv6): self.driver.update_ra(context, network_id) + def validate_networks(self, context, networks): + """check if the networks exists and host + is set to each network. + """ + if networks is None: + return + + result = self.db.project_get_requested_networks(context, networks) + for network_id, fixed_ip in networks: + # check if the fixed IP address is valid and + # it actually belongs to the network + if fixed_ip is not None: + if not utils.is_valid_ipv4(fixed_ip): + raise exception.FixedIpInvalid(address=fixed_ip) + + self.db.fixed_ip_validate_by_network_address(context, + network_id, + fixed_ip) + @property def _bottom_reserved_ips(self): """Number of reserved ips at the bottom of the range.""" diff --git a/nova/utils.py b/nova/utils.py index 8784a227d..22b3a29bf 100644 --- a/nova/utils.py +++ b/nova/utils.py @@ -775,6 +775,22 @@ def bool_from_str(val): return val.lower() == 'true' +def is_valid_ipv4(address): + """valid the address strictly as per format xxx.xxx.xxx.xxx. + where xxx is a value between 0 and 255. + """ + parts = address.split(".") + if len(parts) != 4: + return False + for item in parts: + try: + if not 0 <= int(item) <= 255: + return False + except ValueError: + return False + return True + + class Bootstrapper(object): """Provides environment bootstrapping capabilities for entry points.""" -- cgit From e30a9e1516e44d839ebd5b41586a32e99c47b8c9 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Mon, 11 Jul 2011 14:25:51 -0700 Subject: unknowingly made these changes, reverting to original --- nova/network/manager.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova') diff --git a/nova/network/manager.py b/nova/network/manager.py index 746b2ecc2..dd847ac28 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -349,7 +349,7 @@ class NetworkManager(manager.SchedulerDependentManager): networks = self.db.network_get_all(context) for network in networks: host = network['host'] - if host: + if not host: # return so worker will only grab 1 (to help scale flatter) return self.set_network_host(context, network['id']) -- cgit From bf30f9c1d65053aba29ffff8d8d9a3810455a082 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Mon, 11 Jul 2011 16:02:46 -0700 Subject: fixed all failed unit test cases --- nova/compute/api.py | 8 +++++--- nova/tests/test_network.py | 5 +++-- 2 files changed, 8 insertions(+), 5 deletions(-) (limited to 'nova') diff --git a/nova/compute/api.py b/nova/compute/api.py index ddcb23db5..fd7df4560 100644 --- a/nova/compute/api.py +++ b/nova/compute/api.py @@ -366,7 +366,8 @@ class API(base.Base): key_name=None, key_data=None, security_group='default', availability_zone=None, user_data=None, metadata={}, injected_files=None, admin_password=None, zone_blob=None, - reservation_id=None, block_device_mapping=None): + reservation_id=None, block_device_mapping=None, + requested_networks=None): """Provision the instances by passing the whole request to the Scheduler for execution. Returns a Reservation ID related to the creation of all of these instances.""" @@ -378,13 +379,14 @@ class API(base.Base): key_name, key_data, security_group, availability_zone, user_data, metadata, injected_files, admin_password, zone_blob, - reservation_id) + reservation_id, requested_networks) self._ask_scheduler_to_create_instance(context, base_options, instance_type, zone_blob, availability_zone, injected_files, admin_password, - num_instances=num_instances) + num_instances=num_instances, + requested_networks=requested_networks) return base_options['reservation_id'] diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py index 6d5166019..30e1c0512 100644 --- a/nova/tests/test_network.py +++ b/nova/tests/test_network.py @@ -211,12 +211,13 @@ class VlanNetworkTestCase(test.TestCase): self.network.allocate_fixed_ip(None, 0, network, vpn=True) def test_allocate_fixed_ip(self): - self.mox.StubOutWithMock(db, 'fixed_ip_associate_pool') + self.mox.StubOutWithMock(db, 'fixed_ip_associate_by_address') self.mox.StubOutWithMock(db, 'fixed_ip_update') self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance_and_network') - db.fixed_ip_associate_pool(mox.IgnoreArg(), + db.fixed_ip_associate_by_address(mox.IgnoreArg(), + mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('192.168.0.1') db.fixed_ip_update(mox.IgnoreArg(), -- cgit From 51834c2141bdbc283b9d165372be08eb6b9409ca Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 12 Jul 2011 10:36:55 -0700 Subject: Allowed empty networks, handled RemoteError properly, implemented xml format for networks and fixed broken unit test cases --- nova/api/openstack/create_instance_helper.py | 29 ++++++++++++++++++++++------ nova/network/manager.py | 4 ++-- nova/tests/api/openstack/test_servers.py | 14 ++++++++++++++ 3 files changed, 39 insertions(+), 8 deletions(-) (limited to 'nova') diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index ef2a8393f..5e1c8d8d9 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -25,6 +25,7 @@ from nova import flags from nova import log as logging import nova.image from nova import quota +from nova import rpc from nova import utils from nova.compute import instance_types @@ -104,9 +105,6 @@ class CreateInstanceHelper(object): requested_networks = body['server'].get('networks') if requested_networks is not None: - if len(requested_networks) == 0: - msg = _("No networks found") - raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) requested_networks = self._get_requested_networks( requested_networks) @@ -163,9 +161,9 @@ class CreateInstanceHelper(object): except exception.ImageNotFound as error: msg = _("Can not find requested image") raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) - except exception.NovaException as ex: - LOG.error(ex) - msg = _("Failed to create server: %s") % ex + except rpc.RemoteError as err: + LOG.error(err) + msg = _("%s:%s") % (err.exc_type, err.value) raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) # Let the caller deal with unhandled exceptions. @@ -355,6 +353,9 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer): personality = self._extract_personality(server_node) if personality is not None: server["personality"] = personality + networks = self._extract_networks(server_node) + if networks is not None: + server["networks"] = networks return server def _extract_metadata(self, server_node): @@ -383,6 +384,22 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer): personality.append(item) return personality + def _extract_networks(self, server_node): + """Marshal the networks attribute of a parsed request""" + networks_node = \ + self._find_first_child_named(server_node, "networks") + if networks_node is None: + return None + networks = [] + for network_node in self._find_children_named(networks_node, "network"): + item = {} + if network_node.hasAttribute("id"): + item["id"] = network_node.getAttribute("id") + if network_node.hasAttribute("fixed_ip"): + item["fixed_ip"] = network_node.getAttribute("fixed_ip") + networks.append(item) + return networks + def _find_first_child_named(self, parent, name): """Search a nodes children for the first child with a given name""" for node in parent.childNodes: diff --git a/nova/network/manager.py b/nova/network/manager.py index dd847ac28..90ff81374 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -359,7 +359,7 @@ class NetworkManager(manager.SchedulerDependentManager): # TODO(tr3buchet) maybe this needs to be updated in the future if # there is a better way to determine which networks # a non-vlan instance should connect to - if requested_networks: + if requested_networks is not None and len(requested_networks) != 0: networks = self.db.network_get_requested_networks(context, requested_networks) else: @@ -885,7 +885,7 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): requested_networks=None): """Determine which networks an instance should connect to.""" # get networks associated with project - if requested_networks is not None: + if requested_networks is not None and len(requested_networks) != 0: networks = self.db.project_get_requested_networks(context, requested_networks) else: diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index 8e82a7edc..3bac184d5 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -1902,6 +1902,20 @@ b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""", self.assertEquals(request['body']["server"]["imageRef"], "http://localhost:8774/v1.1/images/1") + def test_request_with_empty_networks(self): + serial_request = """ + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [], + }} + self.assertEquals(request['body'], expected) class TestServerInstanceCreation(test.TestCase): -- cgit From 2be9a4e19449f9cf37f62f3f6e380de3e7ca0d38 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 12 Jul 2011 11:28:06 -0700 Subject: added xml deserialization unit test cases and fixe some pep errors --- nova/api/openstack/create_instance_helper.py | 3 +- nova/tests/api/openstack/test_servers.py | 144 +++++++++++++++++++++++++++ 2 files changed, 146 insertions(+), 1 deletion(-) (limited to 'nova') diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 5e1c8d8d9..86fa8becc 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -391,7 +391,8 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer): if networks_node is None: return None networks = [] - for network_node in self._find_children_named(networks_node, "network"): + for network_node in self._find_children_named(networks_node, + "network"): item = {} if network_node.hasAttribute("id"): item["id"] = network_node.getAttribute("id") diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index 3bac184d5..cde6bd310 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -1917,6 +1917,150 @@ b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""", }} self.assertEquals(request['body'], expected) + def test_request_with_one_network(self): + serial_request = """ + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_two_networks(self): + serial_request = """ + + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, + {"id": "2", "fixed_ip": "10.0.2.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_second_network_node_ignored(self): + serial_request = """ + + + + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_missing_id(self): + serial_request = """ + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_missing_fixed_ip(self): + serial_request = """ + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"id": "1"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_empty_id(self): + serial_request = """ + + + + + """ + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"id": "", "fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_empty_fixed_ip(self): + serial_request = """ + + + + + """ + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"id": "1", "fixed_ip": ""}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_networks_duplicate_ids(self): + serial_request = """ + + + + + + """ + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, + {"id": "1", "fixed_ip": "10.0.2.12"}], + }} + self.assertEquals(request['body'], expected) + + class TestServerInstanceCreation(test.TestCase): def setUp(self): -- cgit From 6e75e608cc7260317f014e57ba070b152f83d0e7 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 12 Jul 2011 17:46:03 -0700 Subject: added unit test cases and minor changes (localization fix and added fixed_ip validation) --- nova/api/openstack/create_instance_helper.py | 18 ++- nova/tests/api/openstack/test_servers.py | 200 ++++++++++++++++++++++++++- 2 files changed, 212 insertions(+), 6 deletions(-) (limited to 'nova') diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 86fa8becc..5eef0ae00 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -162,8 +162,7 @@ class CreateInstanceHelper(object): msg = _("Can not find requested image") raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) except rpc.RemoteError as err: - LOG.error(err) - msg = _("%s:%s") % (err.exc_type, err.value) + msg = _("%(err.exc_type)s:%(err.value)s") raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) # Let the caller deal with unhandled exceptions. @@ -205,6 +204,15 @@ class CreateInstanceHelper(object): msg = _("Server name is an empty string") raise exc.HTTPBadRequest(explanation=msg) + def _validate_fixed_ip(self, value): + if not isinstance(value, basestring): + msg = _("Fixed IP is not a string or unicode") + raise exc.HTTPBadRequest(explanation=msg) + + if value.strip() == '': + msg = _("Fixed IP is an empty string") + raise exc.HTTPBadRequest(explanation=msg) + def _get_kernel_ramdisk_from_image(self, req, image_id): """Fetch an image from the ImageService, then if present, return the associated kernel and ramdisk image IDs. @@ -298,9 +306,10 @@ class CreateInstanceHelper(object): network_id = int(network_id) #fixed IP address is optional #if the fixed IP address is not provided then - #it will used one of the available IP address from the network + #it will use one of the available IP address from the network fixed_ip = network.get('fixed_ip', None) - + if fixed_ip is not None: + self._validate_fixed_ip(fixed_ip) # check if the network id is already present in the list, # we don't want duplicate networks to be passed # at the boot time @@ -404,6 +413,7 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer): def _find_first_child_named(self, parent, name): """Search a nodes children for the first child with a given name""" for node in parent.childNodes: + LOG.debug(node.nodeName) if node.nodeName == name: return node return None diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index cde6bd310..f70ad41cc 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -588,6 +588,11 @@ class ServersTest(test.TestCase): def project_get_networks(context, user_id): return dict(id='1', host='localhost') + def project_get_requested_networks(context, requested_networks): + return [{'id': 1, 'host': 'localhost1'}, + {'id': 2, 'host': 'localhost2'}, + ] + def queue_get_for(context, *args): return 'network_topic' @@ -599,6 +604,8 @@ class ServersTest(test.TestCase): self.stubs.Set(nova.db.api, 'project_get_networks', project_get_networks) + self.stubs.Set(nova.db.api, 'project_get_requested_networks', + project_get_requested_networks) self.stubs.Set(nova.db.api, 'instance_create', instance_create) self.stubs.Set(nova.rpc, 'cast', fake_method) self.stubs.Set(nova.rpc, 'call', fake_method) @@ -901,6 +908,29 @@ class ServersTest(test.TestCase): res = req.get_response(fakes.wsgi_app()) self.assertEqual(res.status_int, 400) + def test_create_instance_whitespace_name(self): + self._setup_for_create_instance() + + body = { + 'server': { + 'name': ' ', + 'imageId': 3, + 'flavorId': 1, + 'metadata': { + 'hello': 'world', + 'open': 'stack', + }, + 'personality': {}, + }, + } + + req = webob.Request.blank('/v1.0/servers') + req.method = 'POST' + req.body = json.dumps(body) + req.headers["content-type"] = "application/json" + res = req.get_response(fakes.wsgi_app()) + self.assertEqual(res.status_int, 400) + def test_update_no_body(self): req = webob.Request.blank('/v1.0/servers/1') req.method = 'PUT' @@ -2078,18 +2108,24 @@ class TestServerInstanceCreation(test.TestCase): FLAGS.allow_admin_api = self.allow_admin super(TestServerInstanceCreation, self).tearDown() - def _setup_mock_compute_api_for_personality(self): + def _setup_mock_compute_api(self): class MockComputeAPI(nova.compute.API): def __init__(self): self.injected_files = None + self.networks = None def create(self, *args, **kwargs): if 'injected_files' in kwargs: self.injected_files = kwargs['injected_files'] else: self.injected_files = None + + if 'requested_networks' in kwargs: + self.networks = kwargs['requested_networks'] + else: + self.networks = None return [{'id': '1234', 'display_name': 'fakeinstance', 'uuid': FAKE_UUID}] @@ -2120,6 +2156,18 @@ class TestServerInstanceCreation(test.TestCase): server['personality'] = personalities return {'server': server} + def _create_networks_request_dict(self, networks): + server = {} + server['name'] = 'new-server-test' + server['imageId'] = 1 + server['flavorId'] = 1 + if networks is not None: + network_list = [] + for id, fixed_ip in networks: + network_list.append({'id': id, 'fixed_ip': fixed_ip}) + server['networks'] = network_list + return {'server': server} + def _get_create_request_json(self, body_dict): req = webob.Request.blank('/v1.0/servers') req.headers['Content-Type'] = 'application/json' @@ -2128,7 +2176,7 @@ class TestServerInstanceCreation(test.TestCase): return req def _run_create_instance_with_mock_compute_api(self, request): - compute_api = self._setup_mock_compute_api_for_personality() + compute_api = self._setup_mock_compute_api() response = request.get_response(fakes.wsgi_app()) return compute_api, response @@ -2153,6 +2201,14 @@ class TestServerInstanceCreation(test.TestCase): item = (file['path'], file['contents']) body_parts.append('%s' % item) body_parts.append('') + if 'networks' in server: + networks = server['networks'] + body_parts.append('') + for network in networks: + item = (network['id'], network['fixed_ip']) + body_parts.append('' + % item) + body_parts.append('') body_parts.append('') return ''.join(body_parts) @@ -2178,6 +2234,20 @@ class TestServerInstanceCreation(test.TestCase): self._run_create_instance_with_mock_compute_api(request) return request, response, compute_api.injected_files + def _create_instance_with_networks_json(self, networks): + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + return request, response, compute_api.networks + + def _create_instance_with_networks_xml(self, networks): + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_xml(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + return request, response, compute_api.networks + def test_create_instance_with_no_personality(self): request, response, injected_files = \ self._create_instance_with_personality_json(personality=None) @@ -2312,6 +2382,132 @@ class TestServerInstanceCreation(test.TestCase): self.assertEquals(server.nodeName, 'server') self.assertEqual(16, len(server.getAttribute('adminPass'))) + def test_create_instance_with_no_networks(self): + request, response, networks = \ + self._create_instance_with_networks_json(networks=None) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, None) + + def test_create_instance_with_no_networks_xml(self): + request, response, networks = \ + self._create_instance_with_networks_xml(networks=None) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, None) + + def test_create_instance_with_one_network(self): + id = 1 + fixed_ip = '10.0.1.12' + networks = [(id, fixed_ip)] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(id, fixed_ip)]) + + def test_create_instance_with_one_network_xml(self): + id = 1 + fixed_ip = '10.0.1.12' + networks = [(id, fixed_ip)] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(id, fixed_ip)]) + + def test_create_instance_with_two_networks(self): + networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) + + def test_create_instance_with_two_networks_xml(self): + networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) + + def test_create_instance_with_duplicate_networks(self): + networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_duplicate_networks_xml(self): + networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_no_id(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + del body_dict['server']['networks'][0]['id'] + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.networks, None) + + def test_create_instance_with_network_no_id_xml(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_xml(body_dict) + request.body = request.body.replace(' id="1"', '') + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.networks, None) + + def test_create_instance_with_network_invalid_id(self): + networks = [('asd123', '10.0.1.12')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_invalid_id_xml(self): + networks = [('asd123', '10.0.1.12')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_empty_fixed_ip(self): + networks = [('1', '')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_empty_fixed_ip_xml(self): + networks = [('1', '')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_no_fixed_ip(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + del body_dict['server']['networks'][0]['fixed_ip'] + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 200) + self.assertEquals(compute_api.networks, [(1, None)]) + + def test_create_instance_with_network_no_fixed_ip_xml(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_xml(body_dict) + request.body = request.body.replace(' fixed_ip="10.0.1.12"', '') + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 200) + self.assertEquals(compute_api.networks, [(1, None)]) + class TestGetKernelRamdiskFromImage(test.TestCase): """ -- cgit From 0b905cc45b940579c6fc7363ecf5657d10a7aeed Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Wed, 13 Jul 2011 12:07:05 -0700 Subject: added unit testcases for validating the requested networks --- nova/tests/test_network.py | 120 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) (limited to 'nova') diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py index 30e1c0512..d6c363481 100644 --- a/nova/tests/test_network.py +++ b/nova/tests/test_network.py @@ -16,6 +16,7 @@ # under the License. from nova import db +from nova import exception from nova import flags from nova import log as logging from nova import test @@ -183,6 +184,65 @@ class FlatNetworkTestCase(test.TestCase): 'netmask': '255.255.255.0'}] self.assertDictListMatch(nw[1]['ips'], check) + def test_validate_networks(self): + self.mox.StubOutWithMock(db, 'network_get_requested_networks') + self.mox.StubOutWithMock(db, "fixed_ip_validate_by_network_address") + + requested_networks = [(1, "192.168.0.100")] + db.network_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + db.fixed_ip_validate_by_network_address(mox.IgnoreArg(), + mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(fixed_ips[0]) + + self.mox.ReplayAll() + self.network.validate_networks(None, requested_networks) + + def test_validate_networks_none_requested_networks(self): + self.network.validate_networks(None, None) + + def test_validate_networks_empty_requested_networks(self): + requested_networks = [] + self.mox.StubOutWithMock(db, 'network_get_requested_networks') + db.network_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.network.validate_networks(None, requested_networks) + + def test_validate_networks_invalid_fixed_ip(self): + self.mox.StubOutWithMock(db, 'network_get_requested_networks') + requested_networks = [(1, "192.168.0.100.1")] + db.network_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.assertRaises(exception.FixedIpInvalid, + self.network.validate_networks, None, + requested_networks) + + def test_validate_networks_empty_fixed_ip(self): + self.mox.StubOutWithMock(db, 'network_get_requested_networks') + + requested_networks = [(1, "")] + db.network_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.assertRaises(exception.FixedIpInvalid, + self.network.validate_networks, + None, requested_networks) + + def test_validate_networks_none_fixed_ip(self): + self.mox.StubOutWithMock(db, 'network_get_requested_networks') + + requested_networks = [(1, None)] + db.network_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.network.validate_networks(None, requested_networks) + class VlanNetworkTestCase(test.TestCase): def setUp(self): @@ -239,3 +299,63 @@ class VlanNetworkTestCase(test.TestCase): self.assertRaises(ValueError, self.network.create_networks, None, num_networks=100, vlan_start=1, cidr='192.168.0.1/24', network_size=100) + + def test_validate_networks(self): + self.mox.StubOutWithMock(db, 'project_get_requested_networks') + self.mox.StubOutWithMock(db, "fixed_ip_validate_by_network_address") + + requested_networks = [(1, "192.168.0.100")] + db.project_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + db.fixed_ip_validate_by_network_address(mox.IgnoreArg(), + mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(fixed_ips[0]) + self.mox.ReplayAll() + + self.network.validate_networks(None, requested_networks) + + def test_validate_networks_none_requested_networks(self): + self.network.validate_networks(None, None) + + def test_validate_networks_empty_requested_networks(self): + requested_networks = [] + self.mox.StubOutWithMock(db, 'project_get_requested_networks') + db.project_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.network.validate_networks(None, requested_networks) + + def test_validate_networks_invalid_fixed_ip(self): + self.mox.StubOutWithMock(db, 'project_get_requested_networks') + + requested_networks = [(1, "192.168.0.100.1")] + db.project_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.assertRaises(exception.FixedIpInvalid, + self.network.validate_networks, + None, requested_networks) + + def test_validate_networks_empty_fixed_ip(self): + self.mox.StubOutWithMock(db, 'project_get_requested_networks') + + requested_networks = [(1, "")] + db.project_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.assertRaises(exception.FixedIpInvalid, + self.network.validate_networks, + None, requested_networks) + + def test_validate_networks_none_fixed_ip(self): + self.mox.StubOutWithMock(db, 'project_get_requested_networks') + + requested_networks = [(1, None)] + db.project_get_requested_networks(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) + self.mox.ReplayAll() + + self.network.validate_networks(None, requested_networks) -- cgit From 2ecbdd46d48bafbeb451875ba6e7f67276d83602 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Wed, 13 Jul 2011 13:57:50 -0700 Subject: Minor fixes --- nova/api/openstack/create_instance_helper.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova') diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 5eef0ae00..0337dd5bb 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -162,7 +162,8 @@ class CreateInstanceHelper(object): msg = _("Can not find requested image") raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) except rpc.RemoteError as err: - msg = _("%(err.exc_type)s:%(err.value)s") + msg = "%(err_type)s: %(err_msg)s" % \ + {'err_type': err.exc_type, 'err_msg': err.value} raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) # Let the caller deal with unhandled exceptions. -- cgit From 0655f97b2cce1e28485ddb4c37a854a65cbbc276 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Thu, 14 Jul 2011 15:53:16 -0700 Subject: added integrated unit testcases and minor fixes --- nova/api/openstack/create_instance_helper.py | 3 - nova/network/manager.py | 6 +- nova/tests/__init__.py | 3 +- nova/tests/api/openstack/test_servers.py | 7 + nova/tests/integrated/test_servers.py | 218 +++++++++++++++++++++++++++ nova/tests/test_network.py | 8 - 6 files changed, 231 insertions(+), 14 deletions(-) (limited to 'nova') diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 0337dd5bb..32b1b2f7c 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -329,9 +329,6 @@ class CreateInstanceHelper(object): expl = _("Bad networks format: network id should " "be integer (%s)") % network_id raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) - except TypeError: - expl = _('Bad networks format') - raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) return networks diff --git a/nova/network/manager.py b/nova/network/manager.py index e665bb1fc..b2b9335a9 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -614,6 +614,7 @@ class NetworkManager(manager.SchedulerDependentManager): net['gateway'] = str(project_net[1]) net['broadcast'] = str(project_net.broadcast) net['dhcp_start'] = str(project_net[2]) + net['project_id'] = kwargs['project_id'] if num_networks > 1: net['label'] = '%s_%d' % (label, index) else: @@ -705,7 +706,7 @@ class NetworkManager(manager.SchedulerDependentManager): """check if the networks exists and host is set to each network. """ - if networks is None: + if networks is None or len(networks) == 0: return result = self.db.network_get_requested_networks(context, networks) @@ -965,10 +966,11 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): """check if the networks exists and host is set to each network. """ - if networks is None: + if networks is None or len(networks) == 0: return result = self.db.project_get_requested_networks(context, networks) + for network_id, fixed_ip in networks: # check if the fixed IP address is valid and # it actually belongs to the network diff --git a/nova/tests/__init__.py b/nova/tests/__init__.py index e4ed75d37..44ce2e635 100644 --- a/nova/tests/__init__.py +++ b/nova/tests/__init__.py @@ -66,7 +66,8 @@ def setup(): bridge=FLAGS.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=FLAGS.vpn_start, - vlan_start=FLAGS.vlan_start) + vlan_start=FLAGS.vlan_start, + project_id="openstack") for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net['id']) diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index 52af4c17a..702dcb7a8 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -2516,6 +2516,13 @@ class TestServerInstanceCreation(test.TestCase): self.assertEquals(response.status_int, 400) self.assertEquals(networks, None) + def test_create_instance_with_network_non_string_fixed_ip(self): + networks = [('1', 12345)] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + def test_create_instance_with_network_empty_fixed_ip_xml(self): networks = [('1', '')] request, response, networks = \ diff --git a/nova/tests/integrated/test_servers.py b/nova/tests/integrated/test_servers.py index fcb517cf5..08522f720 100644 --- a/nova/tests/integrated/test_servers.py +++ b/nova/tests/integrated/test_servers.py @@ -179,6 +179,224 @@ class ServersTest(integrated_helpers._IntegratedTestBase): # Cleanup self._delete_server(created_server_id) + def test_create_server_with_one_networks(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': '10.0.0.3'}] + server['networks'] = network_list + + post = {'server': server} + created_server = self.api.post_server(post) + LOG.debug("created_server: %s" % created_server) + self.assertTrue(created_server['id']) + created_server_id = created_server['id'] + + # Check it's there + found_server = self.api.get_server(created_server_id) + self.assertEqual(created_server_id, found_server['id']) + + # Cleanup + self._delete_server(created_server_id) + + def test_create_server_with_two_networks(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': '10.0.0.3'}, + {'id': 2, 'fixed_ip': '10.0.0.12'}] + + server['networks'] = network_list + + post = {'server': server} + created_server = self.api.post_server(post) + LOG.debug("created_server: %s" % created_server) + self.assertTrue(created_server['id']) + created_server_id = created_server['id'] + + # Check it's there + found_server = self.api.get_server(created_server_id) + self.assertEqual(created_server_id, found_server['id']) + + # Cleanup + self._delete_server(created_server_id) + + def test_create_server_with_empty_networks(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [] + server['networks'] = network_list + + post = {'server': server} + created_server = self.api.post_server(post) + LOG.debug("created_server: %s" % created_server) + self.assertTrue(created_server['id']) + created_server_id = created_server['id'] + + # Check it's there + found_server = self.api.get_server(created_server_id) + self.assertEqual(created_server_id, found_server['id']) + + # Cleanup + self._delete_server(created_server_id) + + def test_create_server_with_networks_invalid_id(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': "invalid", 'fixed_ip': '10.0.0.3'}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + def test_create_server_with_networks_no_id(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'fixed_ip': '10.0.0.3'}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + def test_create_server_with_networks_non_exists_id(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 3, 'fixed_ip': '10.0.0.3'}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + def test_create_server_with_networks_not_found_for_project(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': '10.0.0.3'}, + {'id': 3, 'fixed_ip': '10.0.0.12'}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + def test_create_server_with_networks_invalid_fixed_ip(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': '10.0.0.3.0'}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + def test_create_server_with_networks_non_existing_fixed_ip(self): + """Creates a server with metadata.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': '10.100.0.3'}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + + def test_create_server_with_networks_empty_fixed_ip(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': ''}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + def test_create_server_with_networks_non_string_fixed_ip(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': 12}] + server['networks'] = network_list + + post = {'server': server} + self.assertRaises(client.OpenStackApiException, + self.api.post_server, post) + + def test_create_server_with_networks_none_fixed_ip(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1, 'fixed_ip': None}] + server['networks'] = network_list + + post = {'server': server} + created_server = self.api.post_server(post) + LOG.debug("created_server: %s" % created_server) + self.assertTrue(created_server['id']) + created_server_id = created_server['id'] + + # Check it's there + found_server = self.api.get_server(created_server_id) + self.assertEqual(created_server_id, found_server['id']) + + # Cleanup + self._delete_server(created_server_id) + + def test_create_server_with_networks_no_fixed_ip(self): + """Creates a server with networks.""" + + # Build the server data gradually, checking errors along the way + server = self._build_minimal_create_server_request() + + network_list = [{'id': 1}] + server['networks'] = network_list + + post = {'server': server} + created_server = self.api.post_server(post) + LOG.debug("created_server: %s" % created_server) + self.assertTrue(created_server['id']) + created_server_id = created_server['id'] + + # Check it's there + found_server = self.api.get_server(created_server_id) + self.assertEqual(created_server_id, found_server['id']) + + # Cleanup + self._delete_server(created_server_id) + def test_create_and_rebuild_server(self): """Rebuild a server.""" diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py index 63317b05a..fd4408831 100644 --- a/nova/tests/test_network.py +++ b/nova/tests/test_network.py @@ -203,9 +203,6 @@ class FlatNetworkTestCase(test.TestCase): def test_validate_networks_empty_requested_networks(self): requested_networks = [] - self.mox.StubOutWithMock(db, 'network_get_requested_networks') - db.network_get_requested_networks(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() self.network.validate_networks(None, requested_networks) @@ -319,11 +316,6 @@ class VlanNetworkTestCase(test.TestCase): def test_validate_networks_empty_requested_networks(self): requested_networks = [] - self.mox.StubOutWithMock(db, 'project_get_requested_networks') - db.project_get_requested_networks(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) - self.mox.ReplayAll() - self.network.validate_networks(None, requested_networks) def test_validate_networks_invalid_fixed_ip(self): -- cgit From b4fba58f2785936f68a712d1cdd1d5c34f6a7c22 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Thu, 14 Jul 2011 16:40:05 -0700 Subject: mistakenly commited this code into my branch, reverting it to original from trunk --- nova/rpc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova') diff --git a/nova/rpc.py b/nova/rpc.py index 055f8220e..e2771ca88 100644 --- a/nova/rpc.py +++ b/nova/rpc.py @@ -279,7 +279,7 @@ class FanoutAdapterConsumer(AdapterConsumer): # them when done, so they're not left around on restart. # Also, we're the only one that should be consuming. exclusive # implies auto_delete, so we'll just set that.. - self.exclusive = False + self.exclusive = True LOG.info(_('Created "%(exchange)s" fanout exchange ' 'with "%(key)s" routing key'), dict(exchange=self.exchange, key=self.routing_key)) -- cgit From 6cbd1d860d6a3fe96417391c21fb79b1750ecdcf Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 19 Jul 2011 15:35:54 -0700 Subject: Added a new extension instead of directly making changes to OS V1.1. API --- nova/api/openstack/contrib/createserverext.py | 234 ++++++++++++++++++++++++++ nova/api/openstack/create_instance_helper.py | 51 +----- nova/api/openstack/extensions.py | 9 +- nova/api/openstack/servers.py | 35 ++-- 4 files changed, 262 insertions(+), 67 deletions(-) create mode 100644 nova/api/openstack/contrib/createserverext.py (limited to 'nova') diff --git a/nova/api/openstack/contrib/createserverext.py b/nova/api/openstack/contrib/createserverext.py new file mode 100644 index 000000000..e8fe9afad --- /dev/null +++ b/nova/api/openstack/contrib/createserverext.py @@ -0,0 +1,234 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License +from webob import exc + +from nova import exception +import nova.image +from nova import network +from nova import quota +from nova import rpc + +from nova.api.openstack import create_instance_helper as helper +from nova.api.openstack import extensions +from nova.api.openstack import faults +from nova.compute import instance_types +from nova.api.openstack import servers +from nova.api.openstack import wsgi +from nova.auth import manager as auth_manager + + +class CreateInstanceHelperEx(helper.CreateInstanceHelper): + def __init__(self, controller): + super(CreateInstanceHelperEx, self).__init__(controller) + + def create_instance(self, req, body, create_method): + """Creates a new server for the given user as per + the network information if it is provided + """ + if not body: + raise faults.Fault(exc.HTTPUnprocessableEntity()) + + context = req.environ['nova.context'] + + password = self.controller._get_server_admin_password(body['server']) + + key_name = None + key_data = None + key_pairs = auth_manager.AuthManager.get_key_pairs(context) + if key_pairs: + key_pair = key_pairs[0] + key_name = key_pair['name'] + key_data = key_pair['public_key'] + + image_href = self.controller._image_ref_from_req_data(body) + try: + image_service, image_id = nova.image.get_image_service(image_href) + kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image( + req, image_id) + images = set([str(x['id']) for x in image_service.index(context)]) + assert str(image_id) in images + except Exception, e: + msg = _("Cannot find requested image %(image_href)s: %(e)s" % + locals()) + raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) + + personality = body['server'].get('personality') + + injected_files = [] + if personality: + injected_files = self._get_injected_files(personality) + + requested_networks = body['server'].get('networks') + + if requested_networks is not None: + requested_networks = self._get_requested_networks( + requested_networks) + + flavor_id = self.controller._flavor_id_from_req_data(body) + + if not 'name' in body['server']: + msg = _("Server name is not defined") + raise exc.HTTPBadRequest(explanation=msg) + + zone_blob = body['server'].get('blob') + name = body['server']['name'] + self._validate_server_name(name) + name = name.strip() + + reservation_id = body['server'].get('reservation_id') + min_count = body['server'].get('min_count') + max_count = body['server'].get('max_count') + # min_count and max_count are optional. If they exist, they come + # in as strings. We want to default 'min_count' to 1, and default + # 'max_count' to be 'min_count'. + min_count = int(min_count) if min_count else 1 + max_count = int(max_count) if max_count else min_count + if min_count > max_count: + min_count = max_count + + try: + inst_type = \ + instance_types.get_instance_type_by_flavor_id(flavor_id) + extra_values = { + 'instance_type': inst_type, + 'image_ref': image_href, + 'password': password} + + return (extra_values, + create_method(context, + inst_type, + image_id, + kernel_id=kernel_id, + ramdisk_id=ramdisk_id, + display_name=name, + display_description=name, + key_name=key_name, + key_data=key_data, + metadata=body['server'].get('metadata', {}), + injected_files=injected_files, + admin_password=password, + zone_blob=zone_blob, + reservation_id=reservation_id, + min_count=min_count, + max_count=max_count, + requested_networks=requested_networks)) + except quota.QuotaError as error: + self._handle_quota_error(error) + except exception.ImageNotFound as error: + msg = _("Can not find requested image") + raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) + except rpc.RemoteError as err: + msg = "%(err_type)s: %(err_msg)s" % \ + {'err_type': err.exc_type, 'err_msg': err.value} + raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) + + # Let the caller deal with unhandled exceptions. + + def _get_requested_networks(self, requested_networks): + """ + Create a list of requested networks from the networks attribute + """ + networks = [] + for network in requested_networks: + try: + network_id = network['id'] + network_id = int(network_id) + #fixed IP address is optional + #if the fixed IP address is not provided then + #it will use one of the available IP address from the network + fixed_ip = network.get('fixed_ip', None) + if fixed_ip is not None: + self._validate_fixed_ip(fixed_ip) + # check if the network id is already present in the list, + # we don't want duplicate networks to be passed + # at the boot time + for id, ip in networks: + if id == network_id: + expl = _("Duplicate networks (%s) are not allowed")\ + % network_id + raise faults.Fault(exc.HTTPBadRequest( + explanation=expl)) + + networks.append((network_id, fixed_ip)) + except KeyError as key: + expl = _('Bad network format: missing %s') % key + raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) + except ValueError: + expl = _("Bad networks format: network id should " + "be integer (%s)") % network_id + raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) + except TypeError: + expl = _('Bad networks format') + raise exc.HTTPBadRequest(explanation=expl) + + return networks + + +class CreateServerExtController(servers.ControllerV11): + """This is the controller for the extended version + of the create server OS V1.1 + """ + def __init__(self): + super(CreateServerExtController, self).__init__() + self.helper = CreateInstanceHelperEx(self) + + +class Createserverext(extensions.ExtensionDescriptor): + """The servers create ext + + Exposes addFixedIp and removeFixedIp actions on servers. + + """ + def get_name(self): + return "Createserverext" + + def get_alias(self): + return "os-servers-create-ext" + + def get_description(self): + return "Extended support to the Create Server v1.1 API" + + def get_namespace(self): + return "http://docs.openstack.org/ext/serverscreateext/api/v1.1" + + def get_updated(self): + return "2011-07-19T00:00:00+00:00" + + def get_resources(self): + resources = [] + + headers_serializer = servers.HeadersSerializer() + metadata = servers._get_metadata() + body_serializers = { + 'application/xml': wsgi.XMLDictSerializer(metadata=metadata, + xmlns=wsgi.XMLNS_V11), + } + + body_deserializers = { + 'application/xml': helper.ServerXMLDeserializer(), + } + + serializer = wsgi.ResponseSerializer(body_serializers, + headers_serializer) + deserializer = wsgi.RequestDeserializer(body_deserializers) + + res = extensions.ResourceExtension('os-servers-create-ext', + controller=CreateServerExtController(), + deserializer=deserializer, + serializer=serializer) + resources.append(res) + + return resources diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 32b1b2f7c..8579c45df 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -25,7 +25,6 @@ from nova import flags from nova import log as logging import nova.image from nova import quota -from nova import rpc from nova import utils from nova.compute import instance_types @@ -102,12 +101,6 @@ class CreateInstanceHelper(object): if personality: injected_files = self._get_injected_files(personality) - requested_networks = body['server'].get('networks') - - if requested_networks is not None: - requested_networks = self._get_requested_networks( - requested_networks) - flavor_id = self.controller._flavor_id_from_req_data(body) if not 'name' in body['server']: @@ -154,17 +147,12 @@ class CreateInstanceHelper(object): zone_blob=zone_blob, reservation_id=reservation_id, min_count=min_count, - max_count=max_count, - requested_networks=requested_networks)) + max_count=max_count)) except quota.QuotaError as error: self._handle_quota_error(error) except exception.ImageNotFound as error: msg = _("Can not find requested image") raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) - except rpc.RemoteError as err: - msg = "%(err_type)s: %(err_msg)s" % \ - {'err_type': err.exc_type, 'err_msg': err.value} - raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) # Let the caller deal with unhandled exceptions. @@ -296,42 +284,6 @@ class CreateInstanceHelper(object): raise exc.HTTPBadRequest(explanation=msg) return password - def _get_requested_networks(self, requested_networks): - """ - Create a list of requested networks from the networks attribute - """ - networks = [] - for network in requested_networks: - try: - network_id = network['id'] - network_id = int(network_id) - #fixed IP address is optional - #if the fixed IP address is not provided then - #it will use one of the available IP address from the network - fixed_ip = network.get('fixed_ip', None) - if fixed_ip is not None: - self._validate_fixed_ip(fixed_ip) - # check if the network id is already present in the list, - # we don't want duplicate networks to be passed - # at the boot time - for id, ip in networks: - if id == network_id: - expl = _("Duplicate networks (%s) are not allowed")\ - % network_id - raise faults.Fault(exc.HTTPBadRequest( - explanation=expl)) - - networks.append((network_id, fixed_ip)) - except KeyError as key: - expl = _('Bad network format: missing %s') % key - raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) - except ValueError: - expl = _("Bad networks format: network id should " - "be integer (%s)") % network_id - raise faults.Fault(exc.HTTPBadRequest(explanation=expl)) - - return networks - class ServerXMLDeserializer(wsgi.XMLDeserializer): """ @@ -411,7 +363,6 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer): def _find_first_child_named(self, parent, name): """Search a nodes children for the first child with a given name""" for node in parent.childNodes: - LOG.debug(node.nodeName) if node.nodeName == name: return node return None diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py index da06ecd15..dec66d8a4 100644 --- a/nova/api/openstack/extensions.py +++ b/nova/api/openstack/extensions.py @@ -263,7 +263,9 @@ class ExtensionMiddleware(base_wsgi.Middleware): LOG.debug(_('Extended resource: %s'), resource.collection) mapper.resource(resource.collection, resource.collection, - controller=wsgi.Resource(resource.controller), + controller=wsgi.Resource(resource.controller, + resource.deserializer, + resource.serializer), collection=resource.collection_actions, member=resource.member_actions, parent_resource=resource.parent) @@ -456,9 +458,12 @@ class ResourceExtension(object): """Add top level resources to the OpenStack API in nova.""" def __init__(self, collection, controller, parent=None, - collection_actions={}, member_actions={}): + collection_actions={}, member_actions={}, + deserializer=None, serializer=None): self.collection = collection self.controller = controller self.parent = parent self.collection_actions = collection_actions self.member_actions = member_actions + self.deserializer = deserializer + self.serializer = serializer diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py index 93f8e832c..6a28f7bf1 100644 --- a/nova/api/openstack/servers.py +++ b/nova/api/openstack/servers.py @@ -618,21 +618,7 @@ def create_resource(version='1.0'): '1.1': ControllerV11, }[version]() - metadata = { - "attributes": { - "server": ["id", "imageId", "name", "flavorId", "hostId", - "status", "progress", "adminPass", "flavorRef", - "imageRef"], - "link": ["rel", "type", "href"], - }, - "dict_collections": { - "metadata": {"item_name": "meta", "item_key": "key"}, - }, - "list_collections": { - "public": {"item_name": "ip", "item_key": "addr"}, - "private": {"item_name": "ip", "item_key": "addr"}, - }, - } + metadata = _get_metadata() xmlns = { '1.0': wsgi.XMLNS_V10, @@ -654,3 +640,22 @@ def create_resource(version='1.0'): deserializer = wsgi.RequestDeserializer(body_deserializers) return wsgi.Resource(controller, deserializer, serializer) + + +def _get_metadata(): + metadata = { + "attributes": { + "server": ["id", "imageId", "name", "flavorId", "hostId", + "status", "progress", "adminPass", "flavorRef", + "imageRef"], + "link": ["rel", "type", "href"], + }, + "dict_collections": { + "metadata": {"item_name": "meta", "item_key": "key"}, + }, + "list_collections": { + "public": {"item_name": "ip", "item_key": "addr"}, + "private": {"item_name": "ip", "item_key": "addr"}, + }, + } + return metadata -- cgit From 6b47f87c9e22fa09cedc3e48b7c8dcf52b5d016a Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 19 Jul 2011 17:35:44 -0700 Subject: Fixed broken unit testcases after adding extension and minor code refactoring --- nova/api/openstack/contrib/createserverext.py | 11 +- nova/api/openstack/create_instance_helper.py | 9 - .../api/openstack/contrib/test_createserverext.py | 637 +++++++++++++++++++++ nova/tests/api/openstack/test_servers.py | 151 ----- nova/tests/integrated/test_servers.py | 216 ------- 5 files changed, 647 insertions(+), 377 deletions(-) create mode 100644 nova/tests/api/openstack/contrib/test_createserverext.py (limited to 'nova') diff --git a/nova/api/openstack/contrib/createserverext.py b/nova/api/openstack/contrib/createserverext.py index e8fe9afad..78dba425a 100644 --- a/nova/api/openstack/contrib/createserverext.py +++ b/nova/api/openstack/contrib/createserverext.py @@ -137,6 +137,15 @@ class CreateInstanceHelperEx(helper.CreateInstanceHelper): # Let the caller deal with unhandled exceptions. + def _validate_fixed_ip(self, value): + if not isinstance(value, basestring): + msg = _("Fixed IP is not a string or unicode") + raise exc.HTTPBadRequest(explanation=msg) + + if value.strip() == '': + msg = _("Fixed IP is an empty string") + raise exc.HTTPBadRequest(explanation=msg) + def _get_requested_networks(self, requested_networks): """ Create a list of requested networks from the networks attribute @@ -202,7 +211,7 @@ class Createserverext(extensions.ExtensionDescriptor): return "Extended support to the Create Server v1.1 API" def get_namespace(self): - return "http://docs.openstack.org/ext/serverscreateext/api/v1.1" + return "http://docs.openstack.org/ext/createserverext/api/v1.1" def get_updated(self): return "2011-07-19T00:00:00+00:00" diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 8579c45df..fba0cb8ba 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -193,15 +193,6 @@ class CreateInstanceHelper(object): msg = _("Server name is an empty string") raise exc.HTTPBadRequest(explanation=msg) - def _validate_fixed_ip(self, value): - if not isinstance(value, basestring): - msg = _("Fixed IP is not a string or unicode") - raise exc.HTTPBadRequest(explanation=msg) - - if value.strip() == '': - msg = _("Fixed IP is an empty string") - raise exc.HTTPBadRequest(explanation=msg) - def _get_kernel_ramdisk_from_image(self, req, image_id): """Fetch an image from the ImageService, then if present, return the associated kernel and ramdisk image IDs. diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py new file mode 100644 index 000000000..f2aa136e2 --- /dev/null +++ b/nova/tests/api/openstack/contrib/test_createserverext.py @@ -0,0 +1,637 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2010-2011 OpenStack LLC. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import base64 +import json +import unittest +from xml.dom import minidom + +import stubout +import webob + +from nova import exception +from nova import flags +from nova import test +from nova import utils +import nova.api.openstack +from nova.api.openstack import servers +from nova.api.openstack.contrib import createserverext +import nova.compute.api + +import nova.scheduler.api +import nova.image.fake +import nova.rpc +from nova.tests.api.openstack import fakes + +FLAGS = flags.FLAGS +FLAGS.verbose = True + +FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' + + +def fake_gen_uuid(): + return FAKE_UUID + + +def return_server_by_id(context, id): + return stub_instance(id) + + +def return_server_by_uuid(context, uuid): + id = 1 + return stub_instance(id, uuid=uuid) + + +def return_virtual_interface_by_instance(interfaces): + def _return_virtual_interface_by_instance(context, instance_id): + return interfaces + return _return_virtual_interface_by_instance + + +def return_virtual_interface_instance_nonexistant(interfaces): + def _return_virtual_interface_by_instance(context, instance_id): + raise exception.InstanceNotFound(instance_id=instance_id) + return _return_virtual_interface_by_instance + + +def return_server_with_addresses(private, public): + def _return_server(context, id): + return stub_instance(id, private_address=private, + public_addresses=public) + return _return_server + + +def return_server_with_interfaces(interfaces): + def _return_server(context, id): + return stub_instance(id, interfaces=interfaces) + return _return_server + + +def return_server_with_power_state(power_state): + def _return_server(context, id): + return stub_instance(id, power_state=power_state) + return _return_server + + +def return_servers(context, user_id=1): + return [stub_instance(i, user_id) for i in xrange(5)] + + +def return_servers_by_reservation(context, reservation_id=""): + return [stub_instance(i, reservation_id) for i in xrange(5)] + + +def return_servers_by_reservation_empty(context, reservation_id=""): + return [] + + +def return_servers_from_child_zones_empty(*args, **kwargs): + return [] + + +def return_servers_from_child_zones(*args, **kwargs): + class Server(object): + pass + + zones = [] + for zone in xrange(3): + servers = [] + for server_id in xrange(5): + server = Server() + server._info = stub_instance(server_id, reservation_id="child") + servers.append(server) + + zones.append(("Zone%d" % zone, servers)) + return zones + + +def return_security_group(context, instance_id, security_group_id): + pass + + +def instance_update(context, instance_id, kwargs): + return stub_instance(instance_id) + + +def instance_addresses(context, instance_id): + return None + + +def stub_instance(id, user_id=1, private_address=None, public_addresses=None, + host=None, power_state=0, reservation_id="", + uuid=FAKE_UUID, interfaces=None): + metadata = [] + metadata.append(InstanceMetadata(key='seq', value=id)) + + if interfaces is None: + interfaces = [] + + inst_type = instance_types.get_instance_type_by_flavor_id(1) + + if public_addresses is None: + public_addresses = list() + + if host is not None: + host = str(host) + + # ReservationID isn't sent back, hack it in there. + server_name = "server%s" % id + if reservation_id != "": + server_name = "reservation_%s" % (reservation_id, ) + + instance = { + "id": int(id), + "admin_pass": "", + "user_id": user_id, + "project_id": "", + "image_ref": "10", + "kernel_id": "", + "ramdisk_id": "", + "launch_index": 0, + "key_name": "", + "key_data": "", + "state": power_state, + "state_description": "", + "memory_mb": 0, + "vcpus": 0, + "local_gb": 0, + "hostname": "", + "host": host, + "instance_type": dict(inst_type), + "user_data": "", + "reservation_id": reservation_id, + "mac_address": "", + "scheduled_at": utils.utcnow(), + "launched_at": utils.utcnow(), + "terminated_at": utils.utcnow(), + "availability_zone": "", + "display_name": server_name, + "display_description": "", + "locked": False, + "metadata": metadata, + "uuid": uuid, + "virtual_interfaces": interfaces} + + instance["fixed_ips"] = { + "address": private_address, + "floating_ips": [{"address":ip} for ip in public_addresses]} + + return instance + + +def fake_compute_api(cls, req, id): + return True + + +def find_host(self, context, instance_id): + return "nova" + + +class MockSetAdminPassword(object): + def __init__(self): + self.instance_id = None + self.password = None + + def __call__(self, context, instance_id, password): + self.instance_id = instance_id + self.password = password + + +class CreateserverextTest(test.TestCase): + + def setUp(self): + super(CreateserverextTest, self).setUp() + self.controller = createserverext.CreateServerExtController() + self.stubs = stubout.StubOutForTesting() + fakes.FakeAuthManager.auth_data = {} + fakes.FakeAuthDatabase.data = {} + fakes.stub_out_auth(self.stubs) + fakes.stub_out_image_service(self.stubs) + fakes.stub_out_key_pair_funcs(self.stubs) + self.allow_admin = FLAGS.allow_admin_api + + def tearDown(self): + self.stubs.UnsetAll() + FLAGS.allow_admin_api = self.allow_admin + super(CreateserverextTest, self).tearDown() + + def _setup_mock_compute_api(self): + + class MockComputeAPI(nova.compute.API): + + def __init__(self): + self.injected_files = None + self.networks = None + + def create(self, *args, **kwargs): + if 'injected_files' in kwargs: + self.injected_files = kwargs['injected_files'] + else: + self.injected_files = None + + if 'requested_networks' in kwargs: + self.networks = kwargs['requested_networks'] + else: + self.networks = None + return [{'id': '1234', 'display_name': 'fakeinstance', + 'uuid': FAKE_UUID}] + + def set_admin_password(self, *args, **kwargs): + pass + + def make_stub_method(canned_return): + def stub_method(*args, **kwargs): + return canned_return + return stub_method + + compute_api = MockComputeAPI() + self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api)) + self.stubs.Set( + createserverext.CreateInstanceHelperEx, + '_get_kernel_ramdisk_from_image', make_stub_method((1, 1))) + return compute_api + + def _create_personality_request_dict(self, personality_files): + server = {} + server['name'] = 'new-server-test' + server['imageRef'] = 1 + server['flavorRef'] = 1 + if personality_files is not None: + personalities = [] + for path, contents in personality_files: + personalities.append({'path': path, 'contents': contents}) + server['personality'] = personalities + return {'server': server} + + def _create_networks_request_dict(self, networks): + server = {} + server['name'] = 'new-server-test' + server['imageRef'] = 1 + server['flavorRef'] = 1 + if networks is not None: + network_list = [] + for id, fixed_ip in networks: + network_list.append({'id': id, 'fixed_ip': fixed_ip}) + server['networks'] = network_list + return {'server': server} + + def _get_create_request_json(self, body_dict): + req = webob.Request.blank('/v1.1/os-servers-create-ext') + req.headers['Content-Type'] = 'application/json' + req.method = 'POST' + req.body = json.dumps(body_dict) + return req + + def _run_create_instance_with_mock_compute_api(self, request): + compute_api = self._setup_mock_compute_api() + response = request.get_response(fakes.wsgi_app()) + return compute_api, response + + def _format_xml_request_body(self, body_dict): + server = body_dict['server'] + body_parts = [] + body_parts.extend([ + '', + '' % ( + server['name'], server['imageRef'], server['flavorRef'])]) + if 'metadata' in server: + metadata = server['metadata'] + body_parts.append('') + for item in metadata.iteritems(): + body_parts.append('%s' % item) + body_parts.append('') + if 'personality' in server: + personalities = server['personality'] + body_parts.append('') + for file in personalities: + item = (file['path'], file['contents']) + body_parts.append('%s' % item) + body_parts.append('') + if 'networks' in server: + networks = server['networks'] + body_parts.append('') + for network in networks: + item = (network['id'], network['fixed_ip']) + body_parts.append('' + % item) + body_parts.append('') + body_parts.append('') + return ''.join(body_parts) + + def _get_create_request_xml(self, body_dict): + req = webob.Request.blank('/v1.1/os-servers-create-ext') + req.content_type = 'application/xml' + req.accept = 'application/xml' + req.method = 'POST' + req.body = self._format_xml_request_body(body_dict) + return req + + def _create_instance_with_personality_json(self, personality): + body_dict = self._create_personality_request_dict(personality) + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + return request, response, compute_api.injected_files + + def _create_instance_with_personality_xml(self, personality): + body_dict = self._create_personality_request_dict(personality) + request = self._get_create_request_xml(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + return request, response, compute_api.injected_files + + def _create_instance_with_networks_json(self, networks): + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + return request, response, compute_api.networks + + def _create_instance_with_networks_xml(self, networks): + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_xml(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + return request, response, compute_api.networks + + def test_create_instance_with_no_personality(self): + request, response, injected_files = \ + self._create_instance_with_personality_json(personality=None) + self.assertEquals(response.status_int, 200) + self.assertEquals(injected_files, []) + + def test_create_instance_with_no_personality_xml(self): + request, response, injected_files = \ + self._create_instance_with_personality_xml(personality=None) + self.assertEquals(response.status_int, 200) + self.assertEquals(injected_files, []) + + def test_create_instance_with_personality(self): + path = '/my/file/path' + contents = '#!/bin/bash\necho "Hello, World!"\n' + b64contents = base64.b64encode(contents) + personality = [(path, b64contents)] + request, response, injected_files = \ + self._create_instance_with_personality_json(personality) + self.assertEquals(response.status_int, 200) + self.assertEquals(injected_files, [(path, contents)]) + + def test_create_instance_with_personality_xml(self): + path = '/my/file/path' + contents = '#!/bin/bash\necho "Hello, World!"\n' + b64contents = base64.b64encode(contents) + personality = [(path, b64contents)] + request, response, injected_files = \ + self._create_instance_with_personality_xml(personality) + self.assertEquals(response.status_int, 200) + self.assertEquals(injected_files, [(path, contents)]) + + def test_create_instance_with_personality_no_path(self): + personality = [('/remove/this/path', + base64.b64encode('my\n\file\ncontents'))] + body_dict = self._create_personality_request_dict(personality) + del body_dict['server']['personality'][0]['path'] + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.injected_files, None) + + def _test_create_instance_with_personality_no_path_xml(self): + personality = [('/remove/this/path', + base64.b64encode('my\n\file\ncontents'))] + body_dict = self._create_personality_request_dict(personality) + request = self._get_create_request_xml(body_dict) + request.body = request.body.replace(' path="/remove/this/path"', '') + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.injected_files, None) + + def test_create_instance_with_personality_no_contents(self): + personality = [('/test/path', + base64.b64encode('remove\nthese\ncontents'))] + body_dict = self._create_personality_request_dict(personality) + del body_dict['server']['personality'][0]['contents'] + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.injected_files, None) + + def test_create_instance_with_personality_not_a_list(self): + personality = [('/test/path', base64.b64encode('test\ncontents\n'))] + body_dict = self._create_personality_request_dict(personality) + body_dict['server']['personality'] = \ + body_dict['server']['personality'][0] + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.injected_files, None) + + def test_create_instance_with_personality_with_non_b64_content(self): + path = '/my/file/path' + contents = '#!/bin/bash\necho "Oh no!"\n' + personality = [(path, contents)] + request, response, injected_files = \ + self._create_instance_with_personality_json(personality) + self.assertEquals(response.status_int, 400) + self.assertEquals(injected_files, None) + + def test_create_instance_with_null_personality(self): + personality = None + body_dict = self._create_personality_request_dict(personality) + body_dict['server']['personality'] = None + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 200) + + def test_create_instance_with_three_personalities(self): + files = [ + ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'), + ('/etc/motd', 'Enjoy your root access!\n'), + ('/etc/dovecot.conf', 'dovecot\nconfig\nstuff\n'), + ] + personality = [] + for path, content in files: + personality.append((path, base64.b64encode(content))) + request, response, injected_files = \ + self._create_instance_with_personality_json(personality) + self.assertEquals(response.status_int, 200) + self.assertEquals(injected_files, files) + + def test_create_instance_personality_empty_content(self): + path = '/my/file/path' + contents = '' + personality = [(path, contents)] + request, response, injected_files = \ + self._create_instance_with_personality_json(personality) + self.assertEquals(response.status_int, 200) + self.assertEquals(injected_files, [(path, contents)]) + + def test_create_instance_admin_pass_json(self): + request, response, dummy = \ + self._create_instance_with_personality_json(None) + self.assertEquals(response.status_int, 200) + response = json.loads(response.body) + self.assertTrue('adminPass' in response['server']) + self.assertEqual(16, len(response['server']['adminPass'])) + + def test_create_instance_admin_pass_xml(self): + request, response, dummy = \ + self._create_instance_with_personality_xml(None) + self.assertEquals(response.status_int, 200) + dom = minidom.parseString(response.body) + server = dom.childNodes[0] + self.assertEquals(server.nodeName, 'server') + self.assertEqual(16, len(server.getAttribute('adminPass'))) + + def test_create_instance_with_no_networks(self): + request, response, networks = \ + self._create_instance_with_networks_json(networks=None) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, None) + + def test_create_instance_with_no_networks_xml(self): + request, response, networks = \ + self._create_instance_with_networks_xml(networks=None) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, None) + + def test_create_instance_with_one_network(self): + id = 1 + fixed_ip = '10.0.1.12' + networks = [(id, fixed_ip)] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(id, fixed_ip)]) + + def test_create_instance_with_one_network_xml(self): + id = 1 + fixed_ip = '10.0.1.12' + networks = [(id, fixed_ip)] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(id, fixed_ip)]) + + def test_create_instance_with_two_networks(self): + networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) + + def test_create_instance_with_two_networks_xml(self): + networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 200) + self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) + + def test_create_instance_with_duplicate_networks(self): + networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_duplicate_networks_xml(self): + networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_no_id(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + del body_dict['server']['networks'][0]['id'] + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.networks, None) + + def test_create_instance_with_network_no_id_xml(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_xml(body_dict) + request.body = request.body.replace(' id="1"', '') + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + self.assertEquals(compute_api.networks, None) + + def test_create_instance_with_network_invalid_id(self): + networks = [('asd123', '10.0.1.12')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_invalid_id_xml(self): + networks = [('asd123', '10.0.1.12')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_empty_fixed_ip(self): + networks = [('1', '')] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_non_string_fixed_ip(self): + networks = [('1', 12345)] + request, response, networks = \ + self._create_instance_with_networks_json(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_empty_fixed_ip_xml(self): + networks = [('1', '')] + request, response, networks = \ + self._create_instance_with_networks_xml(networks) + self.assertEquals(response.status_int, 400) + self.assertEquals(networks, None) + + def test_create_instance_with_network_no_fixed_ip(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + del body_dict['server']['networks'][0]['fixed_ip'] + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 200) + self.assertEquals(compute_api.networks, [(1, None)]) + + def test_create_instance_with_network_no_fixed_ip_xml(self): + networks = [(1, '10.0.1.12')] + body_dict = self._create_networks_request_dict(networks) + request = self._get_create_request_xml(body_dict) + request.body = request.body.replace(' fixed_ip="10.0.1.12"', '') + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 200) + self.assertEquals(compute_api.networks, [(1, None)]) diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index b2f1a8ef0..ec7dedafc 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -2324,10 +2324,6 @@ class TestServerInstanceCreation(test.TestCase): else: self.injected_files = None - if 'requested_networks' in kwargs: - self.networks = kwargs['requested_networks'] - else: - self.networks = None return [{'id': '1234', 'display_name': 'fakeinstance', 'uuid': FAKE_UUID}] @@ -2436,20 +2432,6 @@ class TestServerInstanceCreation(test.TestCase): self._run_create_instance_with_mock_compute_api(request) return request, response, compute_api.injected_files - def _create_instance_with_networks_json(self, networks): - body_dict = self._create_networks_request_dict(networks) - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - return request, response, compute_api.networks - - def _create_instance_with_networks_xml(self, networks): - body_dict = self._create_networks_request_dict(networks) - request = self._get_create_request_xml(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - return request, response, compute_api.networks - def test_create_instance_with_no_personality(self): request, response, injected_files = \ self._create_instance_with_personality_json(personality=None) @@ -2584,139 +2566,6 @@ class TestServerInstanceCreation(test.TestCase): self.assertEquals(server.nodeName, 'server') self.assertEqual(16, len(server.getAttribute('adminPass'))) - def test_create_instance_with_no_networks(self): - request, response, networks = \ - self._create_instance_with_networks_json(networks=None) - self.assertEquals(response.status_int, 200) - self.assertEquals(networks, None) - - def test_create_instance_with_no_networks_xml(self): - request, response, networks = \ - self._create_instance_with_networks_xml(networks=None) - self.assertEquals(response.status_int, 200) - self.assertEquals(networks, None) - - def test_create_instance_with_one_network(self): - id = 1 - fixed_ip = '10.0.1.12' - networks = [(id, fixed_ip)] - request, response, networks = \ - self._create_instance_with_networks_json(networks) - self.assertEquals(response.status_int, 200) - self.assertEquals(networks, [(id, fixed_ip)]) - - def test_create_instance_with_one_network_xml(self): - id = 1 - fixed_ip = '10.0.1.12' - networks = [(id, fixed_ip)] - request, response, networks = \ - self._create_instance_with_networks_xml(networks) - self.assertEquals(response.status_int, 200) - self.assertEquals(networks, [(id, fixed_ip)]) - - def test_create_instance_with_two_networks(self): - networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] - request, response, networks = \ - self._create_instance_with_networks_json(networks) - self.assertEquals(response.status_int, 200) - self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) - - def test_create_instance_with_two_networks_xml(self): - networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] - request, response, networks = \ - self._create_instance_with_networks_xml(networks) - self.assertEquals(response.status_int, 200) - self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) - - def test_create_instance_with_duplicate_networks(self): - networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] - request, response, networks = \ - self._create_instance_with_networks_json(networks) - self.assertEquals(response.status_int, 400) - self.assertEquals(networks, None) - - def test_create_instance_with_duplicate_networks_xml(self): - networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] - request, response, networks = \ - self._create_instance_with_networks_xml(networks) - self.assertEquals(response.status_int, 400) - self.assertEquals(networks, None) - - def test_create_instance_with_network_no_id(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) - del body_dict['server']['networks'][0]['id'] - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 400) - self.assertEquals(compute_api.networks, None) - - def test_create_instance_with_network_no_id_xml(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) - request = self._get_create_request_xml(body_dict) - request.body = request.body.replace(' id="1"', '') - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 400) - self.assertEquals(compute_api.networks, None) - - def test_create_instance_with_network_invalid_id(self): - networks = [('asd123', '10.0.1.12')] - request, response, networks = \ - self._create_instance_with_networks_json(networks) - self.assertEquals(response.status_int, 400) - self.assertEquals(networks, None) - - def test_create_instance_with_network_invalid_id_xml(self): - networks = [('asd123', '10.0.1.12')] - request, response, networks = \ - self._create_instance_with_networks_xml(networks) - self.assertEquals(response.status_int, 400) - self.assertEquals(networks, None) - - def test_create_instance_with_network_empty_fixed_ip(self): - networks = [('1', '')] - request, response, networks = \ - self._create_instance_with_networks_json(networks) - self.assertEquals(response.status_int, 400) - self.assertEquals(networks, None) - - def test_create_instance_with_network_non_string_fixed_ip(self): - networks = [('1', 12345)] - request, response, networks = \ - self._create_instance_with_networks_json(networks) - self.assertEquals(response.status_int, 400) - self.assertEquals(networks, None) - - def test_create_instance_with_network_empty_fixed_ip_xml(self): - networks = [('1', '')] - request, response, networks = \ - self._create_instance_with_networks_xml(networks) - self.assertEquals(response.status_int, 400) - self.assertEquals(networks, None) - - def test_create_instance_with_network_no_fixed_ip(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) - del body_dict['server']['networks'][0]['fixed_ip'] - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 200) - self.assertEquals(compute_api.networks, [(1, None)]) - - def test_create_instance_with_network_no_fixed_ip_xml(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) - request = self._get_create_request_xml(body_dict) - request.body = request.body.replace(' fixed_ip="10.0.1.12"', '') - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 200) - self.assertEquals(compute_api.networks, [(1, None)]) - class TestGetKernelRamdiskFromImage(test.TestCase): """ diff --git a/nova/tests/integrated/test_servers.py b/nova/tests/integrated/test_servers.py index 33ffa7cf1..4e8e85c7b 100644 --- a/nova/tests/integrated/test_servers.py +++ b/nova/tests/integrated/test_servers.py @@ -179,222 +179,6 @@ class ServersTest(integrated_helpers._IntegratedTestBase): # Cleanup self._delete_server(created_server_id) - def test_create_server_with_one_networks(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': '10.0.0.3'}] - server['networks'] = network_list - - post = {'server': server} - created_server = self.api.post_server(post) - LOG.debug("created_server: %s" % created_server) - self.assertTrue(created_server['id']) - created_server_id = created_server['id'] - - # Check it's there - found_server = self.api.get_server(created_server_id) - self.assertEqual(created_server_id, found_server['id']) - - # Cleanup - self._delete_server(created_server_id) - - def test_create_server_with_two_networks(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': '10.0.0.3'}, - {'id': 2, 'fixed_ip': '10.0.0.12'}] - server['networks'] = network_list - - post = {'server': server} - created_server = self.api.post_server(post) - LOG.debug("created_server: %s" % created_server) - self.assertTrue(created_server['id']) - created_server_id = created_server['id'] - - # Check it's there - found_server = self.api.get_server(created_server_id) - self.assertEqual(created_server_id, found_server['id']) - - # Cleanup - self._delete_server(created_server_id) - - def test_create_server_with_empty_networks(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [] - server['networks'] = network_list - - post = {'server': server} - created_server = self.api.post_server(post) - LOG.debug("created_server: %s" % created_server) - self.assertTrue(created_server['id']) - created_server_id = created_server['id'] - - # Check it's there - found_server = self.api.get_server(created_server_id) - self.assertEqual(created_server_id, found_server['id']) - - # Cleanup - self._delete_server(created_server_id) - - def test_create_server_with_networks_invalid_id(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': "invalid", 'fixed_ip': '10.0.0.3'}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_no_id(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'fixed_ip': '10.0.0.3'}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_non_exists_id(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 3, 'fixed_ip': '10.0.0.3'}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_not_found_for_project(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': '10.0.0.3'}, - {'id': 3, 'fixed_ip': '10.0.0.12'}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_invalid_fixed_ip(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': '10.0.0.3.0'}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_non_existing_fixed_ip(self): - """Creates a server with metadata.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': '10.100.0.3'}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_empty_fixed_ip(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': ''}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_non_string_fixed_ip(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': 12}] - server['networks'] = network_list - - post = {'server': server} - self.assertRaises(client.OpenStackApiException, - self.api.post_server, post) - - def test_create_server_with_networks_none_fixed_ip(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1, 'fixed_ip': None}] - server['networks'] = network_list - - post = {'server': server} - created_server = self.api.post_server(post) - LOG.debug("created_server: %s" % created_server) - self.assertTrue(created_server['id']) - created_server_id = created_server['id'] - - # Check it's there - found_server = self.api.get_server(created_server_id) - self.assertEqual(created_server_id, found_server['id']) - - # Cleanup - self._delete_server(created_server_id) - - def test_create_server_with_networks_no_fixed_ip(self): - """Creates a server with networks.""" - - # Build the server data gradually, checking errors along the way - server = self._build_minimal_create_server_request() - - network_list = [{'id': 1}] - server['networks'] = network_list - - post = {'server': server} - created_server = self.api.post_server(post) - LOG.debug("created_server: %s" % created_server) - self.assertTrue(created_server['id']) - created_server_id = created_server['id'] - - # Check it's there - found_server = self.api.get_server(created_server_id) - self.assertEqual(created_server_id, found_server['id']) - - # Cleanup - self._delete_server(created_server_id) - def test_create_and_rebuild_server(self): """Rebuild a server.""" -- cgit From c8de39d52d48fc14b851cdd5de8b0d356f3291dc Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 19 Jul 2011 17:38:51 -0700 Subject: Reverted to original code, after network binding to project code is in integration code for testing new extension will be added --- nova/tests/__init__.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova') diff --git a/nova/tests/__init__.py b/nova/tests/__init__.py index 44ce2e635..e4ed75d37 100644 --- a/nova/tests/__init__.py +++ b/nova/tests/__init__.py @@ -66,8 +66,7 @@ def setup(): bridge=FLAGS.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=FLAGS.vpn_start, - vlan_start=FLAGS.vlan_start, - project_id="openstack") + vlan_start=FLAGS.vlan_start) for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net['id']) -- cgit From 038565bdc735ff7a227a39d2ee21df0e8194929b Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 19 Jul 2011 18:24:44 -0700 Subject: Modified alias ^Cd minor fixes --- nova/api/openstack/contrib/createserverext.py | 4 ++-- nova/network/manager.py | 1 - nova/tests/api/openstack/contrib/test_createserverext.py | 4 ++-- 3 files changed, 4 insertions(+), 5 deletions(-) (limited to 'nova') diff --git a/nova/api/openstack/contrib/createserverext.py b/nova/api/openstack/contrib/createserverext.py index 78dba425a..2f8b4389f 100644 --- a/nova/api/openstack/contrib/createserverext.py +++ b/nova/api/openstack/contrib/createserverext.py @@ -205,7 +205,7 @@ class Createserverext(extensions.ExtensionDescriptor): return "Createserverext" def get_alias(self): - return "os-servers-create-ext" + return "os-create-server-ext" def get_description(self): return "Extended support to the Create Server v1.1 API" @@ -234,7 +234,7 @@ class Createserverext(extensions.ExtensionDescriptor): headers_serializer) deserializer = wsgi.RequestDeserializer(body_deserializers) - res = extensions.ResourceExtension('os-servers-create-ext', + res = extensions.ResourceExtension('os-create-server-ext', controller=CreateServerExtController(), deserializer=deserializer, serializer=serializer) diff --git a/nova/network/manager.py b/nova/network/manager.py index 349faa84d..27ea669b4 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -614,7 +614,6 @@ class NetworkManager(manager.SchedulerDependentManager): net['gateway'] = str(project_net[1]) net['broadcast'] = str(project_net.broadcast) net['dhcp_start'] = str(project_net[2]) - net['project_id'] = kwargs['project_id'] if num_networks > 1: net['label'] = '%s_%d' % (label, index) else: diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py index f2aa136e2..5d1687ee9 100644 --- a/nova/tests/api/openstack/contrib/test_createserverext.py +++ b/nova/tests/api/openstack/contrib/test_createserverext.py @@ -290,7 +290,7 @@ class CreateserverextTest(test.TestCase): return {'server': server} def _get_create_request_json(self, body_dict): - req = webob.Request.blank('/v1.1/os-servers-create-ext') + req = webob.Request.blank('/v1.1/os-create-server-ext') req.headers['Content-Type'] = 'application/json' req.method = 'POST' req.body = json.dumps(body_dict) @@ -334,7 +334,7 @@ class CreateserverextTest(test.TestCase): return ''.join(body_parts) def _get_create_request_xml(self, body_dict): - req = webob.Request.blank('/v1.1/os-servers-create-ext') + req = webob.Request.blank('/v1.1/os-create-server-ext') req.content_type = 'application/xml' req.accept = 'application/xml' req.method = 'POST' -- cgit From ae1fd7e73890d361d0bd6ad764118c1e5601cdca Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Thu, 21 Jul 2011 11:25:02 -0700 Subject: pep8 --- nova/network/manager.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'nova') diff --git a/nova/network/manager.py b/nova/network/manager.py index c9a68af68..bafa1c8e8 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -409,9 +409,8 @@ class NetworkManager(manager.SchedulerDependentManager): LOG.debug(_("network allocations for instance %s"), instance_id, context=context) networks = self._get_networks_for_instance(admin_context, - instance_id, - project_id, - requested_networks=requested_networks) + instance_id, project_id, + requested_networks=requested_networks) self._allocate_mac_addresses(context, instance_id, networks) self._allocate_fixed_ips(admin_context, instance_id, host, networks, vpn=vpn, @@ -928,7 +927,7 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): requested_networks) else: networks = self.db.project_get_networks(context, project_id) - return networks; + return networks def create_networks(self, context, **kwargs): """Create networks based on parameters.""" -- cgit From 6c25483c08965204e8a4199ec600098fe09ad87c Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Wed, 27 Jul 2011 15:02:00 -0700 Subject: added unit testcase to increase code coverage --- nova/tests/api/openstack/contrib/test_createserverext.py | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'nova') diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py index 4866f29fe..4db15d2f1 100644 --- a/nova/tests/api/openstack/contrib/test_createserverext.py +++ b/nova/tests/api/openstack/contrib/test_createserverext.py @@ -222,6 +222,16 @@ class CreateserverextTest(test.TestCase): self._run_create_instance_with_mock_compute_api(request) self.assertEquals(response.status_int, 422) + def test_create_instance_with_no_server_name(self): + server = {} + server['imageRef'] = 1 + server['flavorRef'] = 1 + body_dict = {'server': server} + request = self._get_create_request_json(body_dict) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) + self.assertEquals(response.status_int, 400) + def test_create_instance_with_no_personality(self): request, response, injected_files = \ self._create_instance_with_personality_json(personality=None) -- cgit From b0ffe14da11addd2e1fcf14325b9bcf4c8cd3512 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Wed, 27 Jul 2011 15:14:13 -0700 Subject: Reverting to original code --- nova/rpc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova') diff --git a/nova/rpc.py b/nova/rpc.py index 055f8220e..e2771ca88 100644 --- a/nova/rpc.py +++ b/nova/rpc.py @@ -279,7 +279,7 @@ class FanoutAdapterConsumer(AdapterConsumer): # them when done, so they're not left around on restart. # Also, we're the only one that should be consuming. exclusive # implies auto_delete, so we'll just set that.. - self.exclusive = False + self.exclusive = True LOG.info(_('Created "%(exchange)s" fanout exchange ' 'with "%(key)s" routing key'), dict(exchange=self.exchange, key=self.routing_key)) -- cgit From 3335a91c3c53513cc35e3f39a59975b33524950b Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Fri, 29 Jul 2011 18:45:51 -0700 Subject: Fixed review comments: Put parsing logic of network information in create_instance_helper module and refactored unit testcases as per the changed code. --- nova/api/openstack/contrib/createserverext.py | 213 +----------- nova/api/openstack/create_instance_helper.py | 83 ++++- nova/compute/api.py | 1 - nova/network/manager.py | 2 +- .../api/openstack/contrib/test_createserverext.py | 359 +-------------------- nova/tests/api/openstack/test_extensions.py | 6 - nova/tests/api/openstack/test_servers.py | 229 ++++++++++--- 7 files changed, 265 insertions(+), 628 deletions(-) (limited to 'nova') diff --git a/nova/api/openstack/contrib/createserverext.py b/nova/api/openstack/contrib/createserverext.py index b5c06920c..79c017b42 100644 --- a/nova/api/openstack/contrib/createserverext.py +++ b/nova/api/openstack/contrib/createserverext.py @@ -13,220 +13,11 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License -from webob import exc - -from nova import exception -import nova.image -from nova import network -from nova import quota -from nova import rpc from nova.api.openstack import create_instance_helper as helper from nova.api.openstack import extensions -from nova.compute import instance_types from nova.api.openstack import servers from nova.api.openstack import wsgi -from nova.auth import manager as auth_manager - - -class CreateInstanceHelperEx(helper.CreateInstanceHelper): - def __init__(self, controller): - super(CreateInstanceHelperEx, self).__init__(controller) - - def create_instance(self, req, body, create_method): - """Creates a new server for the given user as per - the network information if it is provided - """ - if not body: - raise exc.HTTPUnprocessableEntity() - - if not 'server' in body: - raise exc.HTTPUnprocessableEntity() - - context = req.environ['nova.context'] - - password = self.controller._get_server_admin_password(body['server']) - - key_name = None - key_data = None - key_pairs = auth_manager.AuthManager.get_key_pairs(context) - if key_pairs: - key_pair = key_pairs[0] - key_name = key_pair['name'] - key_data = key_pair['public_key'] - - image_href = self.controller._image_ref_from_req_data(body) - try: - image_service, image_id = nova.image.get_image_service(image_href) - kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image( - req, image_id) - images = set([str(x['id']) for x in image_service.index(context)]) - assert str(image_id) in images - except Exception, e: - msg = _("Cannot find requested image %(image_href)s: %(e)s" % - locals()) - raise exc.HTTPBadRequest(explanation=msg) - - personality = body['server'].get('personality') - - injected_files = [] - if personality: - injected_files = self._get_injected_files(personality) - - requested_networks = body['server'].get('networks') - - if requested_networks is not None: - requested_networks = self._get_requested_networks( - requested_networks) - - flavor_id = self.controller._flavor_id_from_req_data(body) - - if not 'name' in body['server']: - msg = _("Server name is not defined") - raise exc.HTTPBadRequest(explanation=msg) - - zone_blob = body['server'].get('blob') - name = body['server']['name'] - self._validate_server_name(name) - name = name.strip() - - reservation_id = body['server'].get('reservation_id') - min_count = body['server'].get('min_count') - max_count = body['server'].get('max_count') - # min_count and max_count are optional. If they exist, they come - # in as strings. We want to default 'min_count' to 1, and default - # 'max_count' to be 'min_count'. - min_count = int(min_count) if min_count else 1 - max_count = int(max_count) if max_count else min_count - if min_count > max_count: - min_count = max_count - - try: - inst_type = \ - instance_types.get_instance_type_by_flavor_id(flavor_id) - extra_values = { - 'instance_type': inst_type, - 'image_ref': image_href, - 'password': password} - - return (extra_values, - create_method(context, - inst_type, - image_id, - kernel_id=kernel_id, - ramdisk_id=ramdisk_id, - display_name=name, - display_description=name, - key_name=key_name, - key_data=key_data, - metadata=body['server'].get('metadata', {}), - injected_files=injected_files, - admin_password=password, - zone_blob=zone_blob, - reservation_id=reservation_id, - min_count=min_count, - max_count=max_count, - requested_networks=requested_networks)) - except quota.QuotaError as error: - self._handle_quota_error(error) - except exception.ImageNotFound as error: - msg = _("Can not find requested image") - raise exc.HTTPBadRequest(explanation=msg) - except rpc.RemoteError as err: - msg = "%(err_type)s: %(err_msg)s" % \ - {'err_type': err.exc_type, 'err_msg': err.value} - raise exc.HTTPBadRequest(explanation=msg) - - # Let the caller deal with unhandled exceptions. - - def _validate_fixed_ip(self, value): - if not isinstance(value, basestring): - msg = _("Fixed IP is not a string or unicode") - raise exc.HTTPBadRequest(explanation=msg) - - if value.strip() == '': - msg = _("Fixed IP is an empty string") - raise exc.HTTPBadRequest(explanation=msg) - - def _get_requested_networks(self, requested_networks): - """ - Create a list of requested networks from the networks attribute - """ - networks = [] - for network in requested_networks: - try: - network_id = network['id'] - network_id = int(network_id) - #fixed IP address is optional - #if the fixed IP address is not provided then - #it will use one of the available IP address from the network - fixed_ip = network.get('fixed_ip', None) - if fixed_ip is not None: - self._validate_fixed_ip(fixed_ip) - # check if the network id is already present in the list, - # we don't want duplicate networks to be passed - # at the boot time - for id, ip in networks: - if id == network_id: - expl = _("Duplicate networks (%s) are not allowed")\ - % network_id - raise exc.HTTPBadRequest(explanation=expl) - - networks.append((network_id, fixed_ip)) - except KeyError as key: - expl = _('Bad network format: missing %s') % key - raise exc.HTTPBadRequest(explanation=expl) - except ValueError: - expl = _("Bad networks format: network id should " - "be integer (%s)") % network_id - raise exc.HTTPBadRequest(explanation=expl) - except TypeError: - expl = _('Bad networks format') - raise exc.HTTPBadRequest(explanation=expl) - - return networks - - -class CreateServerExtController(servers.ControllerV11): - """This is the controller for the extended version - of the create server OS V1.1 - """ - def __init__(self): - super(CreateServerExtController, self).__init__() - self.helper = CreateInstanceHelperEx(self) - - -class ServerXMLDeserializer(helper.ServerXMLDeserializer): - """ - Deserializer to handle xml-formatted server create requests. - - Handles networks element - """ - def _extract_server(self, node): - """Marshal the server attribute of a parsed request""" - server = super(ServerXMLDeserializer, self)._extract_server(node) - server_node = self.find_first_child_named(node, 'server') - networks = self._extract_networks(server_node) - if networks is not None: - server["networks"] = networks - return server - - def _extract_networks(self, server_node): - """Marshal the networks attribute of a parsed request""" - networks_node = \ - self.find_first_child_named(server_node, "networks") - if networks_node is None: - return None - networks = [] - for network_node in self.find_children_named(networks_node, - "network"): - item = {} - if network_node.hasAttribute("id"): - item["id"] = network_node.getAttribute("id") - if network_node.hasAttribute("fixed_ip"): - item["fixed_ip"] = network_node.getAttribute("fixed_ip") - networks.append(item) - return networks class Createserverext(extensions.ExtensionDescriptor): @@ -261,7 +52,7 @@ class Createserverext(extensions.ExtensionDescriptor): } body_deserializers = { - 'application/xml': ServerXMLDeserializer(), + 'application/xml': helper.ServerXMLDeserializer(), } serializer = wsgi.ResponseSerializer(body_serializers, @@ -269,7 +60,7 @@ class Createserverext(extensions.ExtensionDescriptor): deserializer = wsgi.RequestDeserializer(body_deserializers) res = extensions.ResourceExtension('os-create-server-ext', - controller=CreateServerExtController(), + controller=servers.ControllerV11(), deserializer=deserializer, serializer=serializer) resources.append(res) diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index 04fbeda73..c7cc88313 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -30,6 +30,7 @@ from nova import utils from nova.compute import instance_types from nova.api.openstack import wsgi +from nova.rpc.common import RemoteError LOG = logging.getLogger('nova.api.openstack.create_instance_helper') FLAGS = flags.FLAGS @@ -106,6 +107,12 @@ class CreateInstanceHelper(object): if personality: injected_files = self._get_injected_files(personality) + requested_networks = server_dict.get('networks') + + if requested_networks is not None: + requested_networks = self._get_requested_networks( + requested_networks) + try: flavor_id = self.controller._flavor_id_from_req_data(body) except ValueError as error: @@ -156,7 +163,8 @@ class CreateInstanceHelper(object): zone_blob=zone_blob, reservation_id=reservation_id, min_count=min_count, - max_count=max_count)) + max_count=max_count, + requested_networks=requested_networks)) except quota.QuotaError as error: self._handle_quota_error(error) except exception.ImageNotFound as error: @@ -165,6 +173,10 @@ class CreateInstanceHelper(object): except exception.FlavorNotFound as error: msg = _("Invalid flavorRef provided.") raise exc.HTTPBadRequest(explanation=msg) + except RemoteError as err: + msg = "%(err_type)s: %(err_msg)s" % \ + {'err_type': err.exc_type, 'err_msg': err.value} + raise exc.HTTPBadRequest(explanation=msg) # Let the caller deal with unhandled exceptions. def _handle_quota_error(self, error): @@ -286,6 +298,53 @@ class CreateInstanceHelper(object): raise exc.HTTPBadRequest(explanation=msg) return password + def _validate_fixed_ip(self, value): + if not isinstance(value, basestring): + msg = _("Fixed IP is not a string or unicode") + raise exc.HTTPBadRequest(explanation=msg) + + if value.strip() == '': + msg = _("Fixed IP is an empty string") + raise exc.HTTPBadRequest(explanation=msg) + + def _get_requested_networks(self, requested_networks): + """ + Create a list of requested networks from the networks attribute + """ + networks = [] + for network in requested_networks: + try: + network_id = network['id'] + network_id = int(network_id) + #fixed IP address is optional + #if the fixed IP address is not provided then + #it will use one of the available IP address from the network + fixed_ip = network.get('fixed_ip', None) + if fixed_ip is not None: + self._validate_fixed_ip(fixed_ip) + # check if the network id is already present in the list, + # we don't want duplicate networks to be passed + # at the boot time + for id, ip in networks: + if id == network_id: + expl = _("Duplicate networks (%s) are not allowed")\ + % network_id + raise exc.HTTPBadRequest(explanation=expl) + + networks.append((network_id, fixed_ip)) + except KeyError as key: + expl = _('Bad network format: missing %s') % key + raise exc.HTTPBadRequest(explanation=expl) + except ValueError: + expl = _("Bad networks format: network id should " + "be integer (%s)") % network_id + raise exc.HTTPBadRequest(explanation=expl) + except TypeError: + expl = _('Bad networks format') + raise exc.HTTPBadRequest(explanation=expl) + + return networks + class ServerXMLDeserializer(wsgi.MetadataXMLDeserializer): """ @@ -317,6 +376,10 @@ class ServerXMLDeserializer(wsgi.MetadataXMLDeserializer): server["personality"] = self._extract_personality(server_node) + networks = self._extract_networks(server_node) + if networks: + server["networks"] = networks + return server def _extract_personality(self, server_node): @@ -331,3 +394,21 @@ class ServerXMLDeserializer(wsgi.MetadataXMLDeserializer): item["contents"] = self.extract_text(file_node) personality.append(item) return personality + + def _extract_networks(self, server_node): + """Marshal the networks attribute of a parsed request""" + networks_node = \ + self.find_first_child_named(server_node, "networks") + if networks_node is None: + return None + networks = [] + if networks_node is not None: + for network_node in self.find_children_named(networks_node, + "network"): + item = {} + if network_node.hasAttribute("id"): + item["id"] = network_node.getAttribute("id") + if network_node.hasAttribute("fixed_ip"): + item["fixed_ip"] = network_node.getAttribute("fixed_ip") + networks.append(item) + return networks diff --git a/nova/compute/api.py b/nova/compute/api.py index 818527809..ea7ba0697 100644 --- a/nova/compute/api.py +++ b/nova/compute/api.py @@ -96,7 +96,6 @@ class API(base.Base): if not network_api: network_api = network.API() self.network_api = network_api - self.network_manager = utils.import_object(FLAGS.network_manager) if not volume_api: volume_api = volume.API() self.volume_api = volume_api diff --git a/nova/network/manager.py b/nova/network/manager.py index 62a6732d5..655d5800a 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -407,7 +407,7 @@ class NetworkManager(manager.SchedulerDependentManager): host = kwargs.pop('host') project_id = kwargs.pop('project_id') type_id = kwargs.pop('instance_type_id') - requested_networks = kwargs.pop('requested_networks') + requested_networks = kwargs.get('requested_networks') vpn = kwargs.pop('vpn') admin_context = context.elevated() LOG.debug(_("network allocations for instance %s"), instance_id, diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py index 4db15d2f1..5a033c761 100644 --- a/nova/tests/api/openstack/contrib/test_createserverext.py +++ b/nova/tests/api/openstack/contrib/test_createserverext.py @@ -48,7 +48,6 @@ class CreateserverextTest(test.TestCase): def setUp(self): super(CreateserverextTest, self).setUp() - self.controller = createserverext.CreateServerExtController() self.stubs = stubout.StubOutForTesting() fakes.FakeAuthManager.auth_data = {} fakes.FakeAuthDatabase.data = {} @@ -82,8 +81,8 @@ class CreateserverextTest(test.TestCase): self.networks = None return [{'id': '1234', 'display_name': 'fakeinstance', 'uuid': FAKE_UUID, - 'created_at': "2010-10-10T12:00:00Z", - 'updated_at': "2010-11-11T11:00:00Z"}] + 'created_at': "", + 'updated_at': ""}] def set_admin_password(self, *args, **kwargs): pass @@ -96,22 +95,10 @@ class CreateserverextTest(test.TestCase): compute_api = MockComputeAPI() self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api)) self.stubs.Set( - createserverext.CreateInstanceHelperEx, + nova.api.openstack.create_instance_helper.CreateInstanceHelper, '_get_kernel_ramdisk_from_image', make_stub_method((1, 1))) return compute_api - def _create_personality_request_dict(self, personality_files): - server = {} - server['name'] = 'new-server-test' - server['imageRef'] = 1 - server['flavorRef'] = 1 - if personality_files is not None: - personalities = [] - for path, contents in personality_files: - personalities.append({'path': path, 'contents': contents}) - server['personality'] = personalities - return {'server': server} - def _create_networks_request_dict(self, networks): server = {} server['name'] = 'new-server-test' @@ -176,20 +163,6 @@ class CreateserverextTest(test.TestCase): req.body = self._format_xml_request_body(body_dict) return req - def _create_instance_with_personality_json(self, personality): - body_dict = self._create_personality_request_dict(personality) - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - return request, response, compute_api.injected_files - - def _create_instance_with_personality_xml(self, personality): - body_dict = self._create_personality_request_dict(personality) - request = self._get_create_request_xml(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - return request, response, compute_api.injected_files - def _create_instance_with_networks_json(self, networks): body_dict = self._create_networks_request_dict(networks) request = self._get_create_request_json(body_dict) @@ -204,168 +177,6 @@ class CreateserverextTest(test.TestCase): self._run_create_instance_with_mock_compute_api(request) return request, response, compute_api.networks - def test_create_instance_with_no_server_element(self): - server = {} - server['name'] = 'new-server-test' - server['imageRef'] = 1 - server['flavorRef'] = 1 - body_dict = {'no-server': server} - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 422) - - def test_create_instance_with_no_request_body(self): - body_dict = None - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 422) - - def test_create_instance_with_no_server_name(self): - server = {} - server['imageRef'] = 1 - server['flavorRef'] = 1 - body_dict = {'server': server} - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 400) - - def test_create_instance_with_no_personality(self): - request, response, injected_files = \ - self._create_instance_with_personality_json(personality=None) - self.assertEquals(response.status_int, 200) - self.assertEquals(injected_files, []) - - def test_create_instance_with_no_personality_xml(self): - request, response, injected_files = \ - self._create_instance_with_personality_xml(personality=None) - self.assertEquals(response.status_int, 200) - self.assertEquals(injected_files, []) - - def test_create_instance_with_personality(self): - path = '/my/file/path' - contents = '#!/bin/bash\necho "Hello, World!"\n' - b64contents = base64.b64encode(contents) - personality = [(path, b64contents)] - request, response, injected_files = \ - self._create_instance_with_personality_json(personality) - self.assertEquals(response.status_int, 200) - self.assertEquals(injected_files, [(path, contents)]) - - def test_create_instance_with_personality_xml(self): - path = '/my/file/path' - contents = '#!/bin/bash\necho "Hello, World!"\n' - b64contents = base64.b64encode(contents) - personality = [(path, b64contents)] - request, response, injected_files = \ - self._create_instance_with_personality_xml(personality) - self.assertEquals(response.status_int, 200) - self.assertEquals(injected_files, [(path, contents)]) - - def test_create_instance_with_personality_no_path(self): - personality = [('/remove/this/path', - base64.b64encode('my\n\file\ncontents'))] - body_dict = self._create_personality_request_dict(personality) - del body_dict['server']['personality'][0]['path'] - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 400) - self.assertEquals(compute_api.injected_files, None) - - def _test_create_instance_with_personality_no_path_xml(self): - personality = [('/remove/this/path', - base64.b64encode('my\n\file\ncontents'))] - body_dict = self._create_personality_request_dict(personality) - request = self._get_create_request_xml(body_dict) - request.body = request.body.replace(' path="/remove/this/path"', '') - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 400) - self.assertEquals(compute_api.injected_files, None) - - def test_create_instance_with_personality_no_contents(self): - personality = [('/test/path', - base64.b64encode('remove\nthese\ncontents'))] - body_dict = self._create_personality_request_dict(personality) - del body_dict['server']['personality'][0]['contents'] - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 400) - self.assertEquals(compute_api.injected_files, None) - - def test_create_instance_with_personality_not_a_list(self): - personality = [('/test/path', base64.b64encode('test\ncontents\n'))] - body_dict = self._create_personality_request_dict(personality) - body_dict['server']['personality'] = \ - body_dict['server']['personality'][0] - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 400) - self.assertEquals(compute_api.injected_files, None) - - def test_create_instance_with_personality_with_non_b64_content(self): - path = '/my/file/path' - contents = '#!/bin/bash\necho "Oh no!"\n' - personality = [(path, contents)] - request, response, injected_files = \ - self._create_instance_with_personality_json(personality) - self.assertEquals(response.status_int, 400) - self.assertEquals(injected_files, None) - - def test_create_instance_with_null_personality(self): - personality = None - body_dict = self._create_personality_request_dict(personality) - body_dict['server']['personality'] = None - request = self._get_create_request_json(body_dict) - compute_api, response = \ - self._run_create_instance_with_mock_compute_api(request) - self.assertEquals(response.status_int, 200) - - def test_create_instance_with_three_personalities(self): - files = [ - ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'), - ('/etc/motd', 'Enjoy your root access!\n'), - ('/etc/dovecot.conf', 'dovecot\nconfig\nstuff\n'), - ] - personality = [] - for path, content in files: - personality.append((path, base64.b64encode(content))) - request, response, injected_files = \ - self._create_instance_with_personality_json(personality) - self.assertEquals(response.status_int, 200) - self.assertEquals(injected_files, files) - - def test_create_instance_personality_empty_content(self): - path = '/my/file/path' - contents = '' - personality = [(path, contents)] - request, response, injected_files = \ - self._create_instance_with_personality_json(personality) - self.assertEquals(response.status_int, 200) - self.assertEquals(injected_files, [(path, contents)]) - - def test_create_instance_admin_pass_json(self): - request, response, dummy = \ - self._create_instance_with_personality_json(None) - self.assertEquals(response.status_int, 200) - response = json.loads(response.body) - self.assertTrue('adminPass' in response['server']) - self.assertEqual(16, len(response['server']['adminPass'])) - - def test_create_instance_admin_pass_xml(self): - request, response, dummy = \ - self._create_instance_with_personality_xml(None) - self.assertEquals(response.status_int, 200) - dom = minidom.parseString(response.body) - server = dom.childNodes[0] - self.assertEquals(server.nodeName, 'server') - self.assertEqual(16, len(server.getAttribute('adminPass'))) - def test_create_instance_with_no_networks(self): request, response, networks = \ self._create_instance_with_networks_json(networks=None) @@ -498,167 +309,3 @@ class CreateserverextTest(test.TestCase): self._run_create_instance_with_mock_compute_api(request) self.assertEquals(response.status_int, 200) self.assertEquals(compute_api.networks, [(1, None)]) - - -class TestServerCreateRequestXMLDeserializer(unittest.TestCase): - - def setUp(self): - self.deserializer = createserverext.ServerXMLDeserializer() - - def test_request_with_empty_networks(self): - serial_request = """ - - -""" - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_one_network(self): - serial_request = """ - - - - -""" - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_two_networks(self): - serial_request = """ - - - - - -""" - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, - {"id": "2", "fixed_ip": "10.0.2.12"}], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_second_network_node_ignored(self): - serial_request = """ - - - - - - - -""" - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_one_network_missing_id(self): - serial_request = """ - - - - -""" - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"fixed_ip": "10.0.1.12"}], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_one_network_missing_fixed_ip(self): - serial_request = """ - - - - -""" - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"id": "1"}], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_one_network_empty_id(self): - serial_request = """ - - - - - """ - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"id": "", "fixed_ip": "10.0.1.12"}], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_one_network_empty_fixed_ip(self): - serial_request = """ - - - - - """ - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"id": "1", "fixed_ip": ""}], - }} - self.assertEquals(request['body'], expected) - - def test_request_with_networks_duplicate_ids(self): - serial_request = """ - - - - - - """ - request = self.deserializer.deserialize(serial_request, 'create') - expected = {"server": { - "name": "new-server-test", - "imageId": "1", - "flavorId": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, - {"id": "1", "fixed_ip": "10.0.2.12"}], - }} - self.assertEquals(request['body'], expected) diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py index e71a5f109..50f4d0c09 100644 --- a/nova/tests/api/openstack/test_extensions.py +++ b/nova/tests/api/openstack/test_extensions.py @@ -30,10 +30,6 @@ from nova.api.openstack import wsgi from nova.tests.api.openstack import fakes -from nova import log as logging - -LOG = logging.getLogger('nova.tests.api.openstack.test_extensions') - FLAGS = flags.FLAGS NS = "{http://docs.openstack.org/compute/api/v1.1}" ATOMNS = "{http://www.w3.org/2005/Atom}" @@ -102,8 +98,6 @@ class ExtensionControllerTest(test.TestCase): data = json.loads(response.body) names = [x['name'] for x in data['extensions']] names.sort() - LOG.info("%%%%%%%%%%%%%%%%%%%%%%%%%") - LOG.info(names) self.assertEqual(names, ["Createserverext", "FlavorExtraSpecs", "Floating_ips", "Fox In Socks", "Hosts", "Multinic", "Volumes"]) diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index 418931989..759a3f9cb 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -1125,11 +1125,6 @@ class ServersTest(test.TestCase): def project_get_networks(context, user_id): return dict(id='1', host='localhost') - def project_get_requested_networks(context, requested_networks): - return [{'id': 1, 'host': 'localhost1'}, - {'id': 2, 'host': 'localhost2'}, - ] - def queue_get_for(context, *args): return 'network_topic' @@ -1141,8 +1136,6 @@ class ServersTest(test.TestCase): self.stubs.Set(nova.db.api, 'project_get_networks', project_get_networks) - self.stubs.Set(nova.db.api, 'project_get_requested_networks', - project_get_requested_networks) self.stubs.Set(nova.db.api, 'instance_create', instance_create) self.stubs.Set(nova.rpc, 'cast', fake_method) self.stubs.Set(nova.rpc, 'call', fake_method) @@ -1295,29 +1288,6 @@ class ServersTest(test.TestCase): res = req.get_response(fakes.wsgi_app()) self.assertEqual(res.status_int, 422) - def test_create_instance_whitespace_name(self): - self._setup_for_create_instance() - - body = { - 'server': { - 'name': ' ', - 'imageId': 3, - 'flavorId': 1, - 'metadata': { - 'hello': 'world', - 'open': 'stack', - }, - 'personality': {}, - }, - } - - req = webob.Request.blank('/v1.0/servers') - req.method = 'POST' - req.body = json.dumps(body) - req.headers["content-type"] = "application/json" - res = req.get_response(fakes.wsgi_app()) - self.assertEqual(res.status_int, 400) - def test_create_instance_v1_1(self): self._setup_for_create_instance() @@ -2844,6 +2814,181 @@ class TestServerCreateRequestXMLDeserializerV11(unittest.TestCase): } self.assertEquals(request['body'], expected) + def test_request_with_empty_networks(self): + serial_request = """ + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network(self): + serial_request = """ + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "personality": [], + "metadata": {}, + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_two_networks(self): + serial_request = """ + + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, + {"id": "2", "fixed_ip": "10.0.2.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_second_network_node_ignored(self): + serial_request = """ + + + + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_missing_id(self): + serial_request = """ + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + "networks": [{"fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_missing_fixed_ip(self): + serial_request = """ + + + + +""" + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + "networks": [{"id": "1"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_empty_id(self): + serial_request = """ + + + + + """ + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + "networks": [{"id": "", "fixed_ip": "10.0.1.12"}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_one_network_empty_fixed_ip(self): + serial_request = """ + + + + + """ + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + "networks": [{"id": "1", "fixed_ip": ""}], + }} + self.assertEquals(request['body'], expected) + + def test_request_with_networks_duplicate_ids(self): + serial_request = """ + + + + + + """ + request = self.deserializer.deserialize(serial_request, 'create') + expected = {"server": { + "name": "new-server-test", + "imageId": "1", + "flavorId": "1", + "metadata": {}, + "personality": [], + "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, + {"id": "1", "fixed_ip": "10.0.2.12"}], + }} + self.assertEquals(request['body'], expected) + class TextAddressesXMLSerialization(test.TestCase): @@ -2908,7 +3053,7 @@ class TestServerInstanceCreation(test.TestCase): fakes.stub_out_image_service(self.stubs) fakes.stub_out_key_pair_funcs(self.stubs) - def _setup_mock_compute_api(self): + def _setup_mock_compute_api_for_personality(self): class MockComputeAPI(nova.compute.API): @@ -2952,18 +3097,6 @@ class TestServerInstanceCreation(test.TestCase): server['personality'] = personalities return {'server': server} - def _create_networks_request_dict(self, networks): - server = {} - server['name'] = 'new-server-test' - server['imageId'] = 1 - server['flavorId'] = 1 - if networks is not None: - network_list = [] - for id, fixed_ip in networks: - network_list.append({'id': id, 'fixed_ip': fixed_ip}) - server['networks'] = network_list - return {'server': server} - def _get_create_request_json(self, body_dict): req = webob.Request.blank('/v1.0/servers') req.headers['Content-Type'] = 'application/json' @@ -2972,7 +3105,7 @@ class TestServerInstanceCreation(test.TestCase): return req def _run_create_instance_with_mock_compute_api(self, request): - compute_api = self._setup_mock_compute_api() + compute_api = self._setup_mock_compute_api_for_personality() response = request.get_response(fakes.wsgi_app()) return compute_api, response @@ -2997,14 +3130,6 @@ class TestServerInstanceCreation(test.TestCase): item = (file['path'], file['contents']) body_parts.append('%s' % item) body_parts.append('') - if 'networks' in server: - networks = server['networks'] - body_parts.append('') - for network in networks: - item = (network['id'], network['fixed_ip']) - body_parts.append('' - % item) - body_parts.append('') body_parts.append('') return ''.join(body_parts) -- cgit From fb0b82c0d6af2d67ec9a88842d857b558eaec5d1 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Fri, 5 Aug 2011 15:00:31 -0700 Subject: Refactored code to reduce lines of code and changed method signature --- nova/db/api.py | 12 ++++++------ nova/db/sqlalchemy/api.py | 14 ++------------ nova/network/manager.py | 31 +++++++++++++++++-------------- nova/tests/test_network.py | 32 ++++++++++++++++---------------- 4 files changed, 41 insertions(+), 48 deletions(-) (limited to 'nova') diff --git a/nova/db/api.py b/nova/db/api.py index b98859ef9..789e9bc97 100644 --- a/nova/db/api.py +++ b/nova/db/api.py @@ -710,9 +710,9 @@ def network_get_all(context): return IMPL.network_get_all(context) -def network_get_requested_networks(context, requested_networks): - """Return all defined networks.""" - return IMPL.network_get_requested_networks(context, requested_networks) +def network_get_networks_by_ids(context, network_ids): + """Return networks by ids.""" + return IMPL.network_get_networks_by_ids(context, network_ids) # pylint: disable=C0103 @@ -1262,14 +1262,14 @@ def project_get_networks(context, project_id, associate=True): return IMPL.project_get_networks(context, project_id, associate) -def project_get_requested_networks(context, requested_networks): - """Return the network associated with the project. +def project_get_networks_by_ids(context, network_ids): + """Return the networks by ids associated with the project. If associate is true, it will attempt to associate a new network if one is not found, otherwise it returns None. """ - return IMPL.project_get_requested_networks(context, requested_networks) + return IMPL.project_get_networks_by_ids(context, network_ids) def project_get_networks_v6(context, project_id): diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py index 5de720205..63964a193 100644 --- a/nova/db/sqlalchemy/api.py +++ b/nova/db/sqlalchemy/api.py @@ -1701,13 +1701,8 @@ def network_get_all(context): @require_admin_context -def network_get_requested_networks(context, requested_networks): +def network_get_networks_by_ids(context, network_ids): session = get_session() - - network_ids = [] - for id, fixed_ip in requested_networks: - network_ids.append(id) - result = session.query(models.Network).\ filter(models.Network.id.in_(network_ids)).\ filter_by(deleted=False).all() @@ -2873,13 +2868,8 @@ def project_get_networks(context, project_id, associate=True): @require_context -def project_get_requested_networks(context, requested_networks): +def project_get_networks_by_ids(context, network_ids): session = get_session() - - network_ids = [] - for id, fixed_ip in requested_networks: - network_ids.append(id) - result = session.query(models.Network).\ filter(models.Network.id.in_(network_ids)).\ filter_by(deleted=False).\ diff --git a/nova/network/manager.py b/nova/network/manager.py index 655d5800a..b5c961e2d 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -134,10 +134,9 @@ class RPCAllocateFixedIP(object): for network in networks: address = None if requested_networks is not None: - for id, fixed_ip in requested_networks: - if (network['id'] == id): - address = fixed_ip - break + for address in (fixed_ip for (id, fixed_ip) in \ + requested_networks if network['id'] == id): + break # NOTE(vish): if we are not multi_host pass to the network host if not network['multi_host']: @@ -387,8 +386,9 @@ class NetworkManager(manager.SchedulerDependentManager): # there is a better way to determine which networks # a non-vlan instance should connect to if requested_networks is not None and len(requested_networks) != 0: - networks = self.db.network_get_requested_networks(context, - requested_networks) + network_ids = [id for (id, fixed_ip) in requested_networks] + networks = self.db.network_get_networks_by_ids(context, + network_ids) else: try: networks = self.db.network_get_all(context) @@ -743,7 +743,8 @@ class NetworkManager(manager.SchedulerDependentManager): if networks is None or len(networks) == 0: return - result = self.db.network_get_requested_networks(context, networks) + network_ids = [id for (id, fixed_ip) in networks] + result = self.db.network_get_networks_by_ids(context, network_ids) for network_id, fixed_ip in networks: # check if the fixed IP address is valid and # it actually belongs to the network @@ -793,10 +794,10 @@ class FlatManager(NetworkManager): for network in networks: address = None if requested_networks is not None: - for id, fixed_ip in requested_networks: - if (network['id'] == id): - address = fixed_ip - break + for address in (fixed_ip for (id, fixed_ip) in \ + requested_networks if network['id'] == id): + break + self.allocate_fixed_ip(context, instance_id, network, address=address) @@ -913,8 +914,9 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): """Determine which networks an instance should connect to.""" # get networks associated with project if requested_networks is not None and len(requested_networks) != 0: - networks = self.db.project_get_requested_networks(context, - requested_networks) + network_ids = [id for (id, fixed_ip) in requested_networks] + networks = self.db.project_get_networks_by_ids(context, + network_ids) else: networks = self.db.project_get_networks(context, project_id) return networks @@ -973,7 +975,8 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): if networks is None or len(networks) == 0: return - result = self.db.project_get_requested_networks(context, networks) + network_ids = [id for (id, fixed_ip) in networks] + result = self.db.project_get_networks_by_ids(context, network_ids) for network_id, fixed_ip in networks: # check if the fixed IP address is valid and diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py index 53abbeb4f..9608121bb 100644 --- a/nova/tests/test_network.py +++ b/nova/tests/test_network.py @@ -181,11 +181,11 @@ class FlatNetworkTestCase(test.TestCase): self.assertDictListMatch(nw[1]['ips'], check) def test_validate_networks(self): - self.mox.StubOutWithMock(db, 'network_get_requested_networks') + self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') self.mox.StubOutWithMock(db, "fixed_ip_validate_by_network_address") requested_networks = [(1, "192.168.0.100")] - db.network_get_requested_networks(mox.IgnoreArg(), + db.network_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) db.fixed_ip_validate_by_network_address(mox.IgnoreArg(), mox.IgnoreArg(), @@ -204,9 +204,9 @@ class FlatNetworkTestCase(test.TestCase): self.network.validate_networks(None, requested_networks) def test_validate_networks_invalid_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_requested_networks') + self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') requested_networks = [(1, "192.168.0.100.1")] - db.network_get_requested_networks(mox.IgnoreArg(), + db.network_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -215,10 +215,10 @@ class FlatNetworkTestCase(test.TestCase): requested_networks) def test_validate_networks_empty_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_requested_networks') + self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') requested_networks = [(1, "")] - db.network_get_requested_networks(mox.IgnoreArg(), + db.network_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -227,10 +227,10 @@ class FlatNetworkTestCase(test.TestCase): None, requested_networks) def test_validate_networks_none_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_requested_networks') + self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') requested_networks = [(1, None)] - db.network_get_requested_networks(mox.IgnoreArg(), + db.network_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -294,11 +294,11 @@ class VlanNetworkTestCase(test.TestCase): cidr='192.168.0.1/24', network_size=100) def test_validate_networks(self): - self.mox.StubOutWithMock(db, 'project_get_requested_networks') + self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') self.mox.StubOutWithMock(db, "fixed_ip_validate_by_network_address") requested_networks = [(1, "192.168.0.100")] - db.project_get_requested_networks(mox.IgnoreArg(), + db.project_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) db.fixed_ip_validate_by_network_address(mox.IgnoreArg(), mox.IgnoreArg(), @@ -315,10 +315,10 @@ class VlanNetworkTestCase(test.TestCase): self.network.validate_networks(None, requested_networks) def test_validate_networks_invalid_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_requested_networks') + self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') requested_networks = [(1, "192.168.0.100.1")] - db.project_get_requested_networks(mox.IgnoreArg(), + db.project_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -327,10 +327,10 @@ class VlanNetworkTestCase(test.TestCase): None, requested_networks) def test_validate_networks_empty_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_requested_networks') + self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') requested_networks = [(1, "")] - db.project_get_requested_networks(mox.IgnoreArg(), + db.project_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -339,10 +339,10 @@ class VlanNetworkTestCase(test.TestCase): None, requested_networks) def test_validate_networks_none_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_requested_networks') + self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') requested_networks = [(1, None)] - db.project_get_requested_networks(mox.IgnoreArg(), + db.project_get_networks_by_ids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() -- cgit From 9081e8b62ea01828238ecaebdcf3e627ada3fe9a Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 16 Aug 2011 16:04:18 -0700 Subject: Added uuid for networks and made changes to the Create server API format to accept network as uuid instead of id --- nova/api/openstack/create_instance_helper.py | 39 +++++------ nova/db/api.py | 23 ++----- nova/db/sqlalchemy/api.py | 40 +++--------- .../versions/037_add_uuid_to_networks.py | 43 +++++++++++++ nova/db/sqlalchemy/models.py | 1 + nova/exception.py | 4 +- nova/network/manager.py | 67 +++++++++++-------- .../api/openstack/contrib/test_createserverext.py | 75 ++++++++++------------ nova/tests/api/openstack/test_servers.py | 38 +++++------ nova/tests/test_network.py | 72 ++++++++++++--------- 10 files changed, 211 insertions(+), 191 deletions(-) create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py (limited to 'nova') diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py index c1abd2eb6..8d5a9d2a3 100644 --- a/nova/api/openstack/create_instance_helper.py +++ b/nova/api/openstack/create_instance_helper.py @@ -304,15 +304,6 @@ class CreateInstanceHelper(object): raise exc.HTTPBadRequest(explanation=msg) return password - def _validate_fixed_ip(self, value): - if not isinstance(value, basestring): - msg = _("Fixed IP is not a string or unicode") - raise exc.HTTPBadRequest(explanation=msg) - - if value.strip() == '': - msg = _("Fixed IP is an empty string") - raise exc.HTTPBadRequest(explanation=msg) - def _get_requested_networks(self, requested_networks): """ Create a list of requested networks from the networks attribute @@ -320,31 +311,33 @@ class CreateInstanceHelper(object): networks = [] for network in requested_networks: try: - network_id = network['id'] - network_id = int(network_id) + network_uuid = network['uuid'] + + if not utils.is_uuid_like(network_uuid): + msg = _("Bad networks format: network uuid is not in" + " proper format (%s)") % network_uuid + raise exc.HTTPBadRequest(explanation=msg) + #fixed IP address is optional #if the fixed IP address is not provided then #it will use one of the available IP address from the network - fixed_ip = network.get('fixed_ip', None) - if fixed_ip is not None: - self._validate_fixed_ip(fixed_ip) + address = network.get('fixed_ip', None) + if address is not None and not utils.is_valid_ipv4(address): + msg = _("Invalid fixed IP address (%s)") % address + raise exc.HTTPBadRequest(explanation=msg) # check if the network id is already present in the list, # we don't want duplicate networks to be passed # at the boot time for id, ip in networks: - if id == network_id: + if id == network_uuid: expl = _("Duplicate networks (%s) are not allowed")\ - % network_id + % network_uuid raise exc.HTTPBadRequest(explanation=expl) - networks.append((network_id, fixed_ip)) + networks.append((network_uuid, address)) except KeyError as key: expl = _('Bad network format: missing %s') % key raise exc.HTTPBadRequest(explanation=expl) - except ValueError: - expl = _("Bad networks format: network id should " - "be integer (%s)") % network_id - raise exc.HTTPBadRequest(explanation=expl) except TypeError: expl = _('Bad networks format') raise exc.HTTPBadRequest(explanation=expl) @@ -543,8 +536,8 @@ class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer): for network_node in self.find_children_named(node, "network"): item = {} - if network_node.hasAttribute("id"): - item["id"] = network_node.getAttribute("id") + if network_node.hasAttribute("uuid"): + item["uuid"] = network_node.getAttribute("uuid") if network_node.hasAttribute("fixed_ip"): item["fixed_ip"] = network_node.getAttribute("fixed_ip") networks.append(item) diff --git a/nova/db/api.py b/nova/db/api.py index b6b98daf4..6833e6312 100644 --- a/nova/db/api.py +++ b/nova/db/api.py @@ -404,14 +404,6 @@ def fixed_ip_update(context, address, values): """Create a fixed ip from the values dictionary.""" return IMPL.fixed_ip_update(context, address, values) - -def fixed_ip_validate_by_network_address(context, network_id, - address): - """validates if the address belongs to the network""" - return IMPL.fixed_ip_validate_by_network_address(context, network_id, - address) - - #################### @@ -695,9 +687,9 @@ def network_get_all(context): return IMPL.network_get_all(context) -def network_get_networks_by_ids(context, network_ids): +def network_get_networks_by_uuids(context, network_uuids): """Return networks by ids.""" - return IMPL.network_get_networks_by_ids(context, network_ids) + return IMPL.network_get_networks_by_uuids(context, network_uuids) # pylint: disable=C0103 @@ -1252,14 +1244,9 @@ def project_get_networks(context, project_id, associate=True): return IMPL.project_get_networks(context, project_id, associate) -def project_get_networks_by_ids(context, network_ids): - """Return the networks by ids associated with the project. - - If associate is true, it will attempt to associate a new - network if one is not found, otherwise it returns None. - - """ - return IMPL.project_get_networks_by_ids(context, network_ids) +def project_get_networks_by_uuids(context, network_uuids): + """Return the networks by uuids associated with the project.""" + return IMPL.project_get_networks_by_uuids(context, network_uuids) def project_get_networks_v6(context, project_id): diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py index dde371820..21eb85b2c 100644 --- a/nova/db/sqlalchemy/api.py +++ b/nova/db/sqlalchemy/api.py @@ -824,26 +824,6 @@ def fixed_ip_get_by_address(context, address, session=None): return result -@require_context -def fixed_ip_validate_by_network_address(context, network_id, - address): - session = get_session() - fixed_ip_ref = session.query(models.FixedIp).\ - filter_by(address=address).\ - filter_by(reserved=False).\ - filter_by(network_id=network_id).\ - filter_by(deleted=can_read_deleted(context)).\ - first() - - if fixed_ip_ref is None: - raise exception.FixedIpNotFoundForNetwork(address=address, - network_id=network_id) - if fixed_ip_ref.instance is not None: - raise exception.FixedIpAlreadyInUse(address=address) - - return fixed_ip_ref - - @require_context def fixed_ip_get_by_instance(context, instance_id): session = get_session() @@ -1778,10 +1758,10 @@ def network_get_all(context): @require_admin_context -def network_get_networks_by_ids(context, network_ids): +def network_get_networks_by_uuids(context, network_uuids): session = get_session() result = session.query(models.Network).\ - filter(models.Network.id.in_(network_ids)).\ + filter(models.Network.uuid.in_(network_uuids)).\ filter_by(deleted=False).all() if not result: raise exception.NoNetworksFound() @@ -1794,14 +1774,14 @@ def network_get_networks_by_ids(context, network_ids): #check if the result contains all the networks #we are looking for - for network_id in network_ids: + for network_uuid in network_uuids: found = False for network in result: - if network['id'] == network_id: + if network['uuid'] == network_uuid: found = True break if not found: - raise exception.NetworkNotFound(network_id=network_id) + raise exception.NetworkNotFound(network_id=network_uuid) return result @@ -2962,10 +2942,10 @@ def project_get_networks(context, project_id, associate=True): @require_context -def project_get_networks_by_ids(context, network_ids): +def project_get_networks_by_uuids(context, network_uuids): session = get_session() result = session.query(models.Network).\ - filter(models.Network.id.in_(network_ids)).\ + filter(models.Network.uuid.in_(network_uuids)).\ filter_by(deleted=False).\ filter_by(project_id=context.project_id).all() @@ -2980,14 +2960,14 @@ def project_get_networks_by_ids(context, network_ids): #check if the result contains all the networks #we are looking for - for network_id in network_ids: + for uuid in network_uuids: found = False for network in result: - if network['id'] == network_id: + if network['uuid'] == uuid: found = True break if not found: - raise exception.NetworkNotFoundForProject(network_id=network_id, + raise exception.NetworkNotFoundForProject(network_uuid=uuid, project_id=context.project_id) return result diff --git a/nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py b/nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py new file mode 100644 index 000000000..38c543d51 --- /dev/null +++ b/nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py @@ -0,0 +1,43 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from sqlalchemy import Column, Integer, MetaData, String, Table + +from nova import utils + + +meta = MetaData() + +networks = Table("networks", meta, + Column("id", Integer(), primary_key=True, nullable=False)) +uuid_column = Column("uuid", String(36)) + + +def upgrade(migrate_engine): + meta.bind = migrate_engine + networks.create_column(uuid_column) + + rows = migrate_engine.execute(networks.select()) + for row in rows: + networks_uuid = str(utils.gen_uuid()) + migrate_engine.execute(networks.update()\ + .where(networks.c.id == row[0])\ + .values(uuid=networks_uuid)) + + +def downgrade(migrate_engine): + meta.bind = migrate_engine + networks.drop_column(uuid_column) diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py index f2a4680b0..5cadd156d 100644 --- a/nova/db/sqlalchemy/models.py +++ b/nova/db/sqlalchemy/models.py @@ -557,6 +557,7 @@ class Network(BASE, NovaBase): project_id = Column(String(255)) host = Column(String(255)) # , ForeignKey('hosts.id')) + uuid = Column(String(36)) class VirtualInterface(BASE, NovaBase): diff --git a/nova/exception.py b/nova/exception.py index 0c07934cf..c68c89cad 100644 --- a/nova/exception.py +++ b/nova/exception.py @@ -428,7 +428,7 @@ class NoNetworksFound(NotFound): class NetworkNotFoundForProject(NotFound): - message = _("Either Network %(network_id)s is not present or " + message = _("Either Network uuid %(network_uuid)s is not present or " "is not assigned to the project %(project_id)s.") @@ -471,7 +471,7 @@ class FixedIpNotFoundForHost(FixedIpNotFound): class FixedIpNotFoundForNetwork(FixedIpNotFound): message = _("Fixed IP address (%(address)s) does not exist in " - "network (%(network_id)s).") + "network (%(network_uuid)s).") class FixedIpAlreadyInUse(AlreadyInUse): diff --git a/nova/network/manager.py b/nova/network/manager.py index f8a21fe4b..2f30f8ec1 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -135,8 +135,8 @@ class RPCAllocateFixedIP(object): for network in networks: address = None if requested_networks is not None: - for address in (fixed_ip for (id, fixed_ip) in \ - requested_networks if network['id'] == id): + for address in (fixed_ip for (uuid, fixed_ip) in \ + requested_networks if network['uuid'] == uuid): break # NOTE(vish): if we are not multi_host pass to the network host @@ -397,9 +397,9 @@ class NetworkManager(manager.SchedulerDependentManager): # there is a better way to determine which networks # a non-vlan instance should connect to if requested_networks is not None and len(requested_networks) != 0: - network_ids = [id for (id, fixed_ip) in requested_networks] - networks = self.db.network_get_networks_by_ids(context, - network_ids) + network_uuids = [uuid for (uuid, fixed_ip) in requested_networks] + networks = self.db.network_get_networks_by_uuids(context, + network_uuids) else: try: networks = self.db.network_get_all(context) @@ -827,18 +827,24 @@ class NetworkManager(manager.SchedulerDependentManager): if networks is None or len(networks) == 0: return - network_ids = [id for (id, fixed_ip) in networks] - result = self.db.network_get_networks_by_ids(context, network_ids) - for network_id, fixed_ip in networks: + network_uuids = [uuid for (uuid, fixed_ip) in networks] + + self.db.network_get_networks_by_uuids(context, network_uuids) + + for network_uuid, address in networks: # check if the fixed IP address is valid and # it actually belongs to the network - if fixed_ip is not None: - if not utils.is_valid_ipv4(fixed_ip): - raise exception.FixedIpInvalid(address=fixed_ip) + if address is not None: + if not utils.is_valid_ipv4(address): + raise exception.FixedIpInvalid(address=address) - self.db.fixed_ip_validate_by_network_address(context, - network_id, - fixed_ip) + fixed_ip_ref = self.db.fixed_ip_get_by_address(context, + address) + if fixed_ip_ref['network']['uuid'] != network_uuid: + raise exception.FixedIpNotFoundForNetwork(address=address, + network_uuid=network_uuid) + if fixed_ip_ref['instance'] is not None: + raise exception.FixedIpAlreadyInUse(address=address) class FlatManager(NetworkManager): @@ -878,8 +884,8 @@ class FlatManager(NetworkManager): for network in networks: address = None if requested_networks is not None: - for address in (fixed_ip for (id, fixed_ip) in \ - requested_networks if network['id'] == id): + for address in (fixed_ip for (uuid, fixed_ip) in \ + requested_networks if network['uuid'] == uuid): break self.allocate_fixed_ip(context, instance_id, @@ -999,9 +1005,9 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): """Determine which networks an instance should connect to.""" # get networks associated with project if requested_networks is not None and len(requested_networks) != 0: - network_ids = [id for (id, fixed_ip) in requested_networks] - networks = self.db.project_get_networks_by_ids(context, - network_ids) + network_uuids = [uuid for (uuid, fixed_ip) in requested_networks] + networks = self.db.project_get_networks_by_uuids(context, + network_uuids) else: networks = self.db.project_get_networks(context, project_id) return networks @@ -1060,19 +1066,24 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): if networks is None or len(networks) == 0: return - network_ids = [id for (id, fixed_ip) in networks] - result = self.db.project_get_networks_by_ids(context, network_ids) + network_uuids = [uuid for (uuid, fixed_ip) in networks] - for network_id, fixed_ip in networks: + self.db.project_get_networks_by_uuids(context, network_uuids) + + for network_uuid, address in networks: # check if the fixed IP address is valid and # it actually belongs to the network if fixed_ip is not None: - if not utils.is_valid_ipv4(fixed_ip): - raise exception.FixedIpInvalid(address=fixed_ip) - - self.db.fixed_ip_validate_by_network_address(context, - network_id, - fixed_ip) + if not utils.is_valid_ipv4(address): + raise exception.FixedIpInvalid(address=address) + + fixed_ip_ref = self.db.fixed_ip_get_by_address(context, + address) + if fixed_ip_ref['network']['uuid'] != network_uuid: + raise exception.FixedIpNotFoundForNetwork(address=address, + network_uuid=network_uuid) + if fixed_ip_ref['instance'] is not None: + raise exception.FixedIpAlreadyInUse(address=address) @property def _bottom_reserved_ips(self): diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py index 33a1eec50..38415179a 100644 --- a/nova/tests/api/openstack/contrib/test_createserverext.py +++ b/nova/tests/api/openstack/contrib/test_createserverext.py @@ -43,6 +43,14 @@ FLAGS.verbose = True FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' +FAKE_NETWORKS = [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '10.0.1.12'), + ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', '10.0.2.12')] + +DUPLICATE_NETWORKS = [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '10.0.1.12'), + ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '10.0.1.12')] + +INVALID_NETWORKS = [('invalid', 'invalid-ip-address')] + class CreateserverextTest(test.TestCase): @@ -106,8 +114,8 @@ class CreateserverextTest(test.TestCase): server['flavorRef'] = 1 if networks is not None: network_list = [] - for id, fixed_ip in networks: - network_list.append({'id': id, 'fixed_ip': fixed_ip}) + for uuid, fixed_ip in networks: + network_list.append({'uuid': uuid, 'fixed_ip': fixed_ip}) server['networks'] = network_list return {'server': server} @@ -148,8 +156,8 @@ class CreateserverextTest(test.TestCase): networks = server['networks'] body_parts.append('') for network in networks: - item = (network['id'], network['fixed_ip']) - body_parts.append('' + item = (network['uuid'], network['fixed_ip']) + body_parts.append('' % item) body_parts.append('') body_parts.append('') @@ -190,55 +198,44 @@ class CreateserverextTest(test.TestCase): self.assertEquals(networks, None) def test_create_instance_with_one_network(self): - id = 1 - fixed_ip = '10.0.1.12' - networks = [(id, fixed_ip)] request, response, networks = \ - self._create_instance_with_networks_json(networks) + self._create_instance_with_networks_json([FAKE_NETWORKS[0]]) self.assertEquals(response.status_int, 202) - self.assertEquals(networks, [(id, fixed_ip)]) + self.assertEquals(networks, [FAKE_NETWORKS[0]]) def test_create_instance_with_one_network_xml(self): - id = 1 - fixed_ip = '10.0.1.12' - networks = [(id, fixed_ip)] request, response, networks = \ - self._create_instance_with_networks_xml(networks) + self._create_instance_with_networks_xml([FAKE_NETWORKS[0]]) self.assertEquals(response.status_int, 202) - self.assertEquals(networks, [(id, fixed_ip)]) + self.assertEquals(networks, [FAKE_NETWORKS[0]]) def test_create_instance_with_two_networks(self): - networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] request, response, networks = \ - self._create_instance_with_networks_json(networks) + self._create_instance_with_networks_json(FAKE_NETWORKS) self.assertEquals(response.status_int, 202) - self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) + self.assertEquals(networks, FAKE_NETWORKS) def test_create_instance_with_two_networks_xml(self): - networks = [(1, '10.0.1.12'), (2, '10.0.2.12')] request, response, networks = \ - self._create_instance_with_networks_xml(networks) + self._create_instance_with_networks_xml(FAKE_NETWORKS) self.assertEquals(response.status_int, 202) - self.assertEquals(networks, [(1, '10.0.1.12'), (2, '10.0.2.12')]) + self.assertEquals(networks, FAKE_NETWORKS) def test_create_instance_with_duplicate_networks(self): - networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] request, response, networks = \ - self._create_instance_with_networks_json(networks) + self._create_instance_with_networks_json(DUPLICATE_NETWORKS) self.assertEquals(response.status_int, 400) self.assertEquals(networks, None) def test_create_instance_with_duplicate_networks_xml(self): - networks = [(1, '10.0.1.12'), (1, '10.0.2.12')] request, response, networks = \ - self._create_instance_with_networks_xml(networks) + self._create_instance_with_networks_xml(DUPLICATE_NETWORKS) self.assertEquals(response.status_int, 400) self.assertEquals(networks, None) def test_create_instance_with_network_no_id(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) - del body_dict['server']['networks'][0]['id'] + body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]]) + del body_dict['server']['networks'][0]['uuid'] request = self._get_create_request_json(body_dict) compute_api, response = \ self._run_create_instance_with_mock_compute_api(request) @@ -246,26 +243,24 @@ class CreateserverextTest(test.TestCase): self.assertEquals(compute_api.networks, None) def test_create_instance_with_network_no_id_xml(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) + body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]]) request = self._get_create_request_xml(body_dict) - request.body = request.body.replace(' id="1"', '') + uuid = ' uuid="aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"' + request.body = request.body.replace(uuid, '') compute_api, response = \ self._run_create_instance_with_mock_compute_api(request) self.assertEquals(response.status_int, 400) self.assertEquals(compute_api.networks, None) def test_create_instance_with_network_invalid_id(self): - networks = [('asd123', '10.0.1.12')] request, response, networks = \ - self._create_instance_with_networks_json(networks) + self._create_instance_with_networks_json(INVALID_NETWORKS) self.assertEquals(response.status_int, 400) self.assertEquals(networks, None) def test_create_instance_with_network_invalid_id_xml(self): - networks = [('asd123', '10.0.1.12')] request, response, networks = \ - self._create_instance_with_networks_xml(networks) + self._create_instance_with_networks_xml(INVALID_NETWORKS) self.assertEquals(response.status_int, 400) self.assertEquals(networks, None) @@ -291,21 +286,21 @@ class CreateserverextTest(test.TestCase): self.assertEquals(networks, None) def test_create_instance_with_network_no_fixed_ip(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) + body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]]) del body_dict['server']['networks'][0]['fixed_ip'] request = self._get_create_request_json(body_dict) compute_api, response = \ self._run_create_instance_with_mock_compute_api(request) self.assertEquals(response.status_int, 202) - self.assertEquals(compute_api.networks, [(1, None)]) + self.assertEquals(compute_api.networks, + [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', None)]) def test_create_instance_with_network_no_fixed_ip_xml(self): - networks = [(1, '10.0.1.12')] - body_dict = self._create_networks_request_dict(networks) + body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]]) request = self._get_create_request_xml(body_dict) request.body = request.body.replace(' fixed_ip="10.0.1.12"', '') compute_api, response = \ self._run_create_instance_with_mock_compute_api(request) self.assertEquals(response.status_int, 202) - self.assertEquals(compute_api.networks, [(1, None)]) + self.assertEquals(compute_api.networks, + [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', None)]) diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index 08eb1eb3c..4cfe18c40 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -2662,7 +2662,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): - + """ request = self.deserializer.deserialize(serial_request, 'create') @@ -2670,7 +2670,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): "name": "new-server-test", "imageRef": "1", "flavorRef": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], + "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}], }} self.assertEquals(request['body'], expected) @@ -2679,8 +2679,8 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): - - + + """ request = self.deserializer.deserialize(serial_request, 'create') @@ -2688,8 +2688,8 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): "name": "new-server-test", "imageRef": "1", "flavorRef": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, - {"id": "2", "fixed_ip": "10.0.2.12"}], + "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}, + {"uuid": "2", "fixed_ip": "10.0.2.12"}], }} self.assertEquals(request['body'], expected) @@ -2698,10 +2698,10 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): - + - + """ request = self.deserializer.deserialize(serial_request, 'create') @@ -2709,7 +2709,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): "name": "new-server-test", "imageRef": "1", "flavorRef": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}], + "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}], }} self.assertEquals(request['body'], expected) @@ -2735,7 +2735,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): - + """ request = self.deserializer.deserialize(serial_request, 'create') @@ -2743,7 +2743,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): "name": "new-server-test", "imageRef": "1", "flavorRef": "1", - "networks": [{"id": "1"}], + "networks": [{"uuid": "1"}], }} self.assertEquals(request['body'], expected) @@ -2752,7 +2752,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): - + """ request = self.deserializer.deserialize(serial_request, 'create') @@ -2760,7 +2760,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): "name": "new-server-test", "imageRef": "1", "flavorRef": "1", - "networks": [{"id": "", "fixed_ip": "10.0.1.12"}], + "networks": [{"uuid": "", "fixed_ip": "10.0.1.12"}], }} self.assertEquals(request['body'], expected) @@ -2769,7 +2769,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): - + """ request = self.deserializer.deserialize(serial_request, 'create') @@ -2777,7 +2777,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): "name": "new-server-test", "imageRef": "1", "flavorRef": "1", - "networks": [{"id": "1", "fixed_ip": ""}], + "networks": [{"uuid": "1", "fixed_ip": ""}], }} self.assertEquals(request['body'], expected) @@ -2786,8 +2786,8 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): - - + + """ request = self.deserializer.deserialize(serial_request, 'create') @@ -2795,8 +2795,8 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): "name": "new-server-test", "imageRef": "1", "flavorRef": "1", - "networks": [{"id": "1", "fixed_ip": "10.0.1.12"}, - {"id": "1", "fixed_ip": "10.0.2.12"}], + "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}, + {"uuid": "1", "fixed_ip": "10.0.2.12"}], }} self.assertEquals(request['body'], expected) diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py index f5ab5ae5a..1f01695a8 100644 --- a/nova/tests/test_network.py +++ b/nova/tests/test_network.py @@ -41,6 +41,7 @@ class FakeModel(dict): networks = [{'id': 0, + 'uuid': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", 'label': 'test0', 'injected': False, 'multi_host': False, @@ -60,6 +61,7 @@ networks = [{'id': 0, 'project_id': 'fake_project', 'vpn_public_address': '192.168.0.2'}, {'id': 1, + 'uuid': "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", 'label': 'test1', 'injected': False, 'multi_host': False, @@ -179,15 +181,18 @@ class FlatNetworkTestCase(test.TestCase): self.assertDictListMatch(nw[1]['ips'], check) def test_validate_networks(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') - self.mox.StubOutWithMock(db, "fixed_ip_validate_by_network_address") + self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') + self.mox.StubOutWithMock(db, "fixed_ip_get_by_address") - requested_networks = [(1, "192.168.0.100")] - db.network_get_networks_by_ids(mox.IgnoreArg(), + requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", + "192.168.1.100")] + db.network_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) - db.fixed_ip_validate_by_network_address(mox.IgnoreArg(), - mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(fixed_ips[0]) + + fixed_ips[1]['network'] = FakeModel(**networks[1]) + fixed_ips[1]['instance'] = None + db.fixed_ip_get_by_address(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(fixed_ips[1]) self.mox.ReplayAll() self.network.validate_networks(None, requested_networks) @@ -202,9 +207,9 @@ class FlatNetworkTestCase(test.TestCase): self.network.validate_networks(None, requested_networks) def test_validate_networks_invalid_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') + self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') requested_networks = [(1, "192.168.0.100.1")] - db.network_get_networks_by_ids(mox.IgnoreArg(), + db.network_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -213,10 +218,10 @@ class FlatNetworkTestCase(test.TestCase): requested_networks) def test_validate_networks_empty_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') + self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') requested_networks = [(1, "")] - db.network_get_networks_by_ids(mox.IgnoreArg(), + db.network_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -225,10 +230,10 @@ class FlatNetworkTestCase(test.TestCase): None, requested_networks) def test_validate_networks_none_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_ids') + self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') requested_networks = [(1, None)] - db.network_get_networks_by_ids(mox.IgnoreArg(), + db.network_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -271,7 +276,8 @@ class VlanNetworkTestCase(test.TestCase): db.instance_get(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'security_groups': [{'id': 0}]}) - db.fixed_ip_associate_pool(mox.IgnoreArg(), + db.fixed_ip_associate_by_address(mox.IgnoreArg(), + mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('192.168.0.1') db.fixed_ip_update(mox.IgnoreArg(), @@ -295,17 +301,20 @@ class VlanNetworkTestCase(test.TestCase): cidr='192.168.0.1/24', network_size=100) def test_validate_networks(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') - self.mox.StubOutWithMock(db, "fixed_ip_validate_by_network_address") + self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') + self.mox.StubOutWithMock(db, "fixed_ip_get_by_address") - requested_networks = [(1, "192.168.0.100")] - db.project_get_networks_by_ids(mox.IgnoreArg(), + requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", + "192.168.1.100")] + db.project_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) - db.fixed_ip_validate_by_network_address(mox.IgnoreArg(), - mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(fixed_ips[0]) - self.mox.ReplayAll() + fixed_ips[1]['network'] = FakeModel(**networks[1]) + fixed_ips[1]['instance'] = None + db.fixed_ip_get_by_address(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(fixed_ips[1]) + + self.mox.ReplayAll() self.network.validate_networks(None, requested_networks) def test_validate_networks_none_requested_networks(self): @@ -313,25 +322,26 @@ class VlanNetworkTestCase(test.TestCase): def test_validate_networks_empty_requested_networks(self): requested_networks = [] + self.mox.ReplayAll() + self.network.validate_networks(None, requested_networks) def test_validate_networks_invalid_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') - + self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') requested_networks = [(1, "192.168.0.100.1")] - db.project_get_networks_by_ids(mox.IgnoreArg(), + db.project_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() self.assertRaises(exception.FixedIpInvalid, - self.network.validate_networks, - None, requested_networks) + self.network.validate_networks, None, + requested_networks) def test_validate_networks_empty_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') + self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') requested_networks = [(1, "")] - db.project_get_networks_by_ids(mox.IgnoreArg(), + db.project_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -340,10 +350,10 @@ class VlanNetworkTestCase(test.TestCase): None, requested_networks) def test_validate_networks_none_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_ids') + self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') requested_networks = [(1, None)] - db.project_get_networks_by_ids(mox.IgnoreArg(), + db.project_get_networks_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() -- cgit From 69c26210dd821df0d2160e51b10f147db2a40249 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Wed, 17 Aug 2011 12:08:14 -0700 Subject: Fixed broken unit testcases --- nova/tests/api/openstack/test_extensions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova') diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py index 9c29363c6..878ec00e5 100644 --- a/nova/tests/api/openstack/test_extensions.py +++ b/nova/tests/api/openstack/test_extensions.py @@ -85,7 +85,7 @@ class ExtensionControllerTest(test.TestCase): ext_path = os.path.join(os.path.dirname(__file__), "extensions") self.flags(osapi_extensions_path=ext_path) self.ext_list = [ - "Createserverext" + "Createserverext", "FlavorExtraSpecs", "Floating_ips", "Fox In Socks", -- cgit From d27a4d4a59a0103762ece2776ddd484629a72d54 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Fri, 19 Aug 2011 14:25:41 -0700 Subject: Fixed review comments --- nova/db/api.py | 21 +---- nova/db/sqlalchemy/api.py | 104 ++++++--------------- .../versions/037_add_uuid_to_networks.py | 43 --------- .../versions/039_add_uuid_to_networks.py | 43 +++++++++ nova/exception.py | 6 +- nova/network/manager.py | 68 ++++++-------- nova/tests/test_network.py | 81 ++++++++-------- 7 files changed, 151 insertions(+), 215 deletions(-) delete mode 100644 nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/039_add_uuid_to_networks.py (limited to 'nova') diff --git a/nova/db/api.py b/nova/db/api.py index 6833e6312..34d560ca3 100644 --- a/nova/db/api.py +++ b/nova/db/api.py @@ -323,13 +323,13 @@ def migration_get_by_instance_and_status(context, instance_uuid, status): #################### -def fixed_ip_associate(context, address, instance_id): +def fixed_ip_associate(context, address, instance_id, network_id=None): """Associate fixed ip to instance. Raises if fixed ip is not available. """ - return IMPL.fixed_ip_associate(context, address, instance_id) + return IMPL.fixed_ip_associate(context, address, instance_id, network_id) def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None): @@ -342,14 +342,6 @@ def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None): instance_id, host) -def fixed_ip_associate_by_address(context, network_id, instance_id, address): - """check if the address is free and is in the network - and it is not associated to any instance. - """ - return IMPL.fixed_ip_associate_by_address(context, network_id, - instance_id, address) - - def fixed_ip_create(context, values): """Create a fixed ip from the values dictionary.""" return IMPL.fixed_ip_create(context, values) @@ -687,9 +679,9 @@ def network_get_all(context): return IMPL.network_get_all(context) -def network_get_networks_by_uuids(context, network_uuids): +def network_get_all_by_uuids(context, network_uuids, project_id=None): """Return networks by ids.""" - return IMPL.network_get_networks_by_uuids(context, network_uuids) + return IMPL.network_get_all_by_uuids(context, network_uuids, project_id) # pylint: disable=C0103 @@ -1244,11 +1236,6 @@ def project_get_networks(context, project_id, associate=True): return IMPL.project_get_networks(context, project_id, associate) -def project_get_networks_by_uuids(context, network_uuids): - """Return the networks by uuids associated with the project.""" - return IMPL.project_get_networks_by_uuids(context, network_uuids) - - def project_get_networks_v6(context, project_id): return IMPL.project_get_networks_v6(context, project_id) diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py index 5aa49213a..005500058 100644 --- a/nova/db/sqlalchemy/api.py +++ b/nova/db/sqlalchemy/api.py @@ -266,7 +266,7 @@ def service_get_all_network_sorted(context): session = get_session() with session.begin(): topic = 'network' - label = 'network_' + label = 'network_count' subq = session.query(models.Network.host, func.count(models.Network.id).label(label)).\ filter_by(deleted=False).\ @@ -652,23 +652,36 @@ def floating_ip_update(context, address, values): ################### -@require_context -def fixed_ip_associate(context, address, instance_id): +@require_admin_context +def fixed_ip_associate(context, address, instance_id, network_id=None): session = get_session() with session.begin(): - instance = instance_get(context, instance_id, session=session) + network_or_none = or_(models.FixedIp.network_id == network_id, + models.FixedIp.network_id == None) fixed_ip_ref = session.query(models.FixedIp).\ - filter_by(address=address).\ + filter(network_or_none).\ + filter_by(reserved=False).\ filter_by(deleted=False).\ - filter_by(instance=None).\ + filter_by(address=address).\ with_lockmode('update').\ first() # NOTE(vish): if with_lockmode isn't supported, as in sqlite, # then this has concurrency issues - if not fixed_ip_ref: - raise exception.NoMoreFixedIps() - fixed_ip_ref.instance = instance + if fixed_ip_ref is None: + raise exception.FixedIpNotFoundForNetwork(address=address, + network_id=network_id) + if fixed_ip_ref.instance is not None: + raise exception.FixedIpAlreadyInUse(address=address) + + if not fixed_ip_ref.network: + fixed_ip_ref.network = network_get(context, + network_id, + session=session) + fixed_ip_ref.instance = instance_get(context, + instance_id, + session=session) session.add(fixed_ip_ref) + return fixed_ip_ref['address'] @require_admin_context @@ -703,40 +716,6 @@ def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None): return fixed_ip_ref['address'] -@require_admin_context -def fixed_ip_associate_by_address(context, network_id, instance_id, - address): - if address is None: - return fixed_ip_associate_pool(context, network_id, instance_id) - - session = get_session() - with session.begin(): - fixed_ip_ref = session.query(models.FixedIp).\ - filter_by(reserved=False).\ - filter_by(deleted=False).\ - filter_by(network_id=network_id).\ - filter_by(address=address).\ - with_lockmode('update').\ - first() - # NOTE(vish): if with_lockmode isn't supported, as in sqlite, - # then this has concurrency issues - if fixed_ip_ref is None: - raise exception.FixedIpNotFoundForNetwork(address=address, - network_id=network_id) - if fixed_ip_ref.instance is not None: - raise exception.FixedIpAlreadyInUse(address=address) - - if not fixed_ip_ref.network: - fixed_ip_ref.network = network_get(context, - network_id, - session=session) - fixed_ip_ref.instance = instance_get(context, - instance_id, - session=session) - session.add(fixed_ip_ref) - return fixed_ip_ref['address'] - - @require_context def fixed_ip_create(_context, values): fixed_ip_ref = models.FixedIp() @@ -1777,10 +1756,13 @@ def network_get_all(context): @require_admin_context -def network_get_networks_by_uuids(context, network_uuids): +def network_get_all_by_uuids(context, network_uuids, project_id=None): session = get_session() + project_or_none = or_(models.Network.project_id == project_id, + models.Network.project_id == None) result = session.query(models.Network).\ filter(models.Network.uuid.in_(network_uuids)).\ + filter(project_or_none).\ filter_by(deleted=False).all() if not result: raise exception.NoNetworksFound() @@ -1800,6 +1782,9 @@ def network_get_networks_by_uuids(context, network_uuids): found = True break if not found: + if project_id: + raise exception.NetworkNotFoundForProject(network_uuid=uuid, + project_id=context.project_id) raise exception.NetworkNotFound(network_id=network_uuid) return result @@ -2961,37 +2946,6 @@ def project_get_networks(context, project_id, associate=True): return result -@require_context -def project_get_networks_by_uuids(context, network_uuids): - session = get_session() - result = session.query(models.Network).\ - filter(models.Network.uuid.in_(network_uuids)).\ - filter_by(deleted=False).\ - filter_by(project_id=context.project_id).all() - - if not result: - raise exception.NoNetworksFound() - - #check if host is set to all of the networks - # returned in the result - for network in result: - if network['host'] is None: - raise exception.NetworkHostNotSet(network_id=network['id']) - - #check if the result contains all the networks - #we are looking for - for uuid in network_uuids: - found = False - for network in result: - if network['uuid'] == uuid: - found = True - break - if not found: - raise exception.NetworkNotFoundForProject(network_uuid=uuid, - project_id=context.project_id) - return result - - @require_context def project_get_networks_v6(context, project_id): return project_get_networks(context, project_id) diff --git a/nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py b/nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py deleted file mode 100644 index 38c543d51..000000000 --- a/nova/db/sqlalchemy/migrate_repo/versions/037_add_uuid_to_networks.py +++ /dev/null @@ -1,43 +0,0 @@ -# vim: tabstop=4 shiftwidth=4 softtabstop=4 - -# Copyright 2011 OpenStack LLC. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -from sqlalchemy import Column, Integer, MetaData, String, Table - -from nova import utils - - -meta = MetaData() - -networks = Table("networks", meta, - Column("id", Integer(), primary_key=True, nullable=False)) -uuid_column = Column("uuid", String(36)) - - -def upgrade(migrate_engine): - meta.bind = migrate_engine - networks.create_column(uuid_column) - - rows = migrate_engine.execute(networks.select()) - for row in rows: - networks_uuid = str(utils.gen_uuid()) - migrate_engine.execute(networks.update()\ - .where(networks.c.id == row[0])\ - .values(uuid=networks_uuid)) - - -def downgrade(migrate_engine): - meta.bind = migrate_engine - networks.drop_column(uuid_column) diff --git a/nova/db/sqlalchemy/migrate_repo/versions/039_add_uuid_to_networks.py b/nova/db/sqlalchemy/migrate_repo/versions/039_add_uuid_to_networks.py new file mode 100644 index 000000000..38c543d51 --- /dev/null +++ b/nova/db/sqlalchemy/migrate_repo/versions/039_add_uuid_to_networks.py @@ -0,0 +1,43 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from sqlalchemy import Column, Integer, MetaData, String, Table + +from nova import utils + + +meta = MetaData() + +networks = Table("networks", meta, + Column("id", Integer(), primary_key=True, nullable=False)) +uuid_column = Column("uuid", String(36)) + + +def upgrade(migrate_engine): + meta.bind = migrate_engine + networks.create_column(uuid_column) + + rows = migrate_engine.execute(networks.select()) + for row in rows: + networks_uuid = str(utils.gen_uuid()) + migrate_engine.execute(networks.update()\ + .where(networks.c.id == row[0])\ + .values(uuid=networks_uuid)) + + +def downgrade(migrate_engine): + meta.bind = migrate_engine + networks.drop_column(uuid_column) diff --git a/nova/exception.py b/nova/exception.py index 97275fa25..262122990 100644 --- a/nova/exception.py +++ b/nova/exception.py @@ -185,10 +185,6 @@ class Invalid(NovaException): message = _("Unacceptable parameters.") -class AlreadyInUse(NovaException): - message = _("Already is in use.") - - class InvalidSignature(Invalid): message = _("Invalid signature %(signature)s for user %(user)s.") @@ -474,7 +470,7 @@ class FixedIpNotFoundForNetwork(FixedIpNotFound): "network (%(network_uuid)s).") -class FixedIpAlreadyInUse(AlreadyInUse): +class FixedIpAlreadyInUse(NovaException): message = _("Fixed IP address %(address)s is already in use.") diff --git a/nova/network/manager.py b/nova/network/manager.py index 9565c879f..aa2a3700c 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -399,8 +399,8 @@ class NetworkManager(manager.SchedulerDependentManager): # a non-vlan instance should connect to if requested_networks is not None and len(requested_networks) != 0: network_uuids = [uuid for (uuid, fixed_ip) in requested_networks] - networks = self.db.network_get_networks_by_uuids(context, - network_uuids) + networks = self.db.network_get_all_by_uuids(context, + network_uuids) else: try: networks = self.db.network_get_all(context) @@ -588,10 +588,15 @@ class NetworkManager(manager.SchedulerDependentManager): # network_get_by_compute_host address = None if network['cidr']: - address = self.db.fixed_ip_associate_by_address(context.elevated(), - network['id'], - instance_id, - kwargs.get('address', None)) + address = kwargs.get('address', None) + if address: + address = self.db.fixed_ip_associate(context, + address, instance_id, + network['id']) + else: + address = self.db.fixed_ip_associate_pool(context.elevated(), + network['id'], + instance_id) self._do_trigger_security_group_members_refresh_for_instance( instance_id) get_vif = self.db.virtual_interface_get_by_instance_and_network @@ -826,7 +831,7 @@ class NetworkManager(manager.SchedulerDependentManager): network_uuids = [uuid for (uuid, fixed_ip) in networks] - self.db.network_get_networks_by_uuids(context, network_uuids) + self._get_networks_by_uuids(context, network_uuids) for network_uuid, address in networks: # check if the fixed IP address is valid and @@ -843,6 +848,9 @@ class NetworkManager(manager.SchedulerDependentManager): if fixed_ip_ref['instance'] is not None: raise exception.FixedIpAlreadyInUse(address=address) + def _get_networks_by_uuids(self, context, network_uuids): + return self.db.network_get_all_by_uuids(context, network_uuids) + class FlatManager(NetworkManager): """Basic network where no vlans are used. @@ -980,10 +988,15 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): address, instance_id) else: - address = self.db.fixed_ip_associate_by_address(context, - network['id'], - instance_id, - kwargs.get('address', None)) + address = kwargs.get('address', None) + if address: + address = self.db.fixed_ip_associate(context, address, + instance_id, + network['id']) + else: + address = self.db.fixed_ip_associate_pool(context, + network['id'], + instance_id) self._do_trigger_security_group_members_refresh_for_instance( instance_id) vif = self.db.virtual_interface_get_by_instance_and_network(context, @@ -1005,8 +1018,9 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): # get networks associated with project if requested_networks is not None and len(requested_networks) != 0: network_uuids = [uuid for (uuid, fixed_ip) in requested_networks] - networks = self.db.project_get_networks_by_uuids(context, - network_uuids) + networks = self.db.network_get_all_by_uuids(context, + network_uuids, + project_id) else: networks = self.db.project_get_networks(context, project_id) return networks @@ -1058,31 +1072,9 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): self.db.network_update(context, network_ref['id'], {'gateway_v6': gateway}) - def validate_networks(self, context, networks): - """check if the networks exists and host - is set to each network. - """ - if networks is None or len(networks) == 0: - return - - network_uuids = [uuid for (uuid, fixed_ip) in networks] - - self.db.project_get_networks_by_uuids(context, network_uuids) - - for network_uuid, address in networks: - # check if the fixed IP address is valid and - # it actually belongs to the network - if fixed_ip is not None: - if not utils.is_valid_ipv4(address): - raise exception.FixedIpInvalid(address=address) - - fixed_ip_ref = self.db.fixed_ip_get_by_address(context, - address) - if fixed_ip_ref['network']['uuid'] != network_uuid: - raise exception.FixedIpNotFoundForNetwork(address=address, - network_uuid=network_uuid) - if fixed_ip_ref['instance'] is not None: - raise exception.FixedIpAlreadyInUse(address=address) + def _get_networks_by_uuids(self, context, network_uuids): + return self.db.network_get_all_by_uuids(context, network_uuids, + context.project_id) @property def _bottom_reserved_ips(self): diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py index 86fa9ee7f..0b8539442 100644 --- a/nova/tests/test_network.py +++ b/nova/tests/test_network.py @@ -15,6 +15,7 @@ # License for the specific language governing permissions and limitations # under the License. +from nova import context from nova import db from nova import exception from nova import log as logging @@ -128,6 +129,8 @@ class FlatNetworkTestCase(test.TestCase): super(FlatNetworkTestCase, self).setUp() self.network = network_manager.FlatManager(host=HOST) self.network.db = db + self.context = context.RequestContext('testuser', 'testproject', + is_admin=False) def test_get_instance_nw_info(self): self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance') @@ -186,13 +189,13 @@ class FlatNetworkTestCase(test.TestCase): self.assertDictListMatch(nw[1]['ips'], check) def test_validate_networks(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') self.mox.StubOutWithMock(db, "fixed_ip_get_by_address") requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", "192.168.1.100")] - db.network_get_networks_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + db.network_get_all_by_uuids(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) fixed_ips[1]['network'] = FakeModel(**networks[1]) fixed_ips[1]['instance'] = None @@ -200,22 +203,22 @@ class FlatNetworkTestCase(test.TestCase): mox.IgnoreArg()).AndReturn(fixed_ips[1]) self.mox.ReplayAll() - self.network.validate_networks(None, requested_networks) + self.network.validate_networks(self.context, requested_networks) def test_validate_networks_none_requested_networks(self): - self.network.validate_networks(None, None) + self.network.validate_networks(self.context, None) def test_validate_networks_empty_requested_networks(self): requested_networks = [] self.mox.ReplayAll() - self.network.validate_networks(None, requested_networks) + self.network.validate_networks(self.context, requested_networks) def test_validate_networks_invalid_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') requested_networks = [(1, "192.168.0.100.1")] - db.network_get_networks_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + db.network_get_all_by_uuids(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() self.assertRaises(exception.FixedIpInvalid, @@ -223,11 +226,11 @@ class FlatNetworkTestCase(test.TestCase): requested_networks) def test_validate_networks_empty_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') requested_networks = [(1, "")] - db.network_get_networks_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + db.network_get_all_by_uuids(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() self.assertRaises(exception.FixedIpInvalid, @@ -235,10 +238,10 @@ class FlatNetworkTestCase(test.TestCase): None, requested_networks) def test_validate_networks_none_fixed_ip(self): - self.mox.StubOutWithMock(db, 'network_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') requested_networks = [(1, None)] - db.network_get_networks_by_uuids(mox.IgnoreArg(), + db.network_get_all_by_uuids(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() @@ -250,6 +253,8 @@ class VlanNetworkTestCase(test.TestCase): super(VlanNetworkTestCase, self).setUp() self.network = network_manager.VlanManager(host=HOST) self.network.db = db + self.context = context.RequestContext('testuser', 'testproject', + is_admin=False) def test_vpn_allocate_fixed_ip(self): self.mox.StubOutWithMock(db, 'fixed_ip_associate') @@ -272,7 +277,7 @@ class VlanNetworkTestCase(test.TestCase): self.network.allocate_fixed_ip(None, 0, network, vpn=True) def test_allocate_fixed_ip(self): - self.mox.StubOutWithMock(db, 'fixed_ip_associate_by_address') + self.mox.StubOutWithMock(db, 'fixed_ip_associate_pool') self.mox.StubOutWithMock(db, 'fixed_ip_update') self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance_and_network') @@ -281,8 +286,7 @@ class VlanNetworkTestCase(test.TestCase): db.instance_get(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'security_groups': [{'id': 0}]}) - db.fixed_ip_associate_by_address(mox.IgnoreArg(), - mox.IgnoreArg(), + db.fixed_ip_associate_pool(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('192.168.0.1') db.fixed_ip_update(mox.IgnoreArg(), @@ -294,7 +298,7 @@ class VlanNetworkTestCase(test.TestCase): network = dict(networks[0]) network['vpn_private_address'] = '192.168.0.2' - self.network.allocate_fixed_ip(None, 0, network) + self.network.allocate_fixed_ip(self.context, 0, network) def test_create_networks_too_big(self): self.assertRaises(ValueError, self.network.create_networks, None, @@ -306,13 +310,14 @@ class VlanNetworkTestCase(test.TestCase): cidr='192.168.0.1/24', network_size=100) def test_validate_networks(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') self.mox.StubOutWithMock(db, "fixed_ip_get_by_address") requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", "192.168.1.100")] - db.project_get_networks_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + db.network_get_all_by_uuids(mox.IgnoreArg(), + mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) fixed_ips[1]['network'] = FakeModel(**networks[1]) fixed_ips[1]['instance'] = None @@ -320,49 +325,51 @@ class VlanNetworkTestCase(test.TestCase): mox.IgnoreArg()).AndReturn(fixed_ips[1]) self.mox.ReplayAll() - self.network.validate_networks(None, requested_networks) + self.network.validate_networks(self.context, requested_networks) def test_validate_networks_none_requested_networks(self): - self.network.validate_networks(None, None) + self.network.validate_networks(self.context, None) def test_validate_networks_empty_requested_networks(self): requested_networks = [] self.mox.ReplayAll() - self.network.validate_networks(None, requested_networks) + self.network.validate_networks(self.context, requested_networks) def test_validate_networks_invalid_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') requested_networks = [(1, "192.168.0.100.1")] - db.project_get_networks_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + db.network_get_all_by_uuids(mox.IgnoreArg(), + mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() self.assertRaises(exception.FixedIpInvalid, - self.network.validate_networks, None, + self.network.validate_networks, self.context, requested_networks) def test_validate_networks_empty_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') requested_networks = [(1, "")] - db.project_get_networks_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + db.network_get_all_by_uuids(mox.IgnoreArg(), + mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() self.assertRaises(exception.FixedIpInvalid, self.network.validate_networks, - None, requested_networks) + self.context, requested_networks) def test_validate_networks_none_fixed_ip(self): - self.mox.StubOutWithMock(db, 'project_get_networks_by_uuids') + self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') requested_networks = [(1, None)] - db.project_get_networks_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + db.network_get_all_by_uuids(mox.IgnoreArg(), + mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn(networks) self.mox.ReplayAll() - - self.network.validate_networks(None, requested_networks) + self.network.validate_networks(self.context, requested_networks) class CommonNetworkTestCase(test.TestCase): -- cgit