Our goal is to add optional parameter to the Create server OS 1.0 and 1.1 API to achieve following objectives:-

1) Specify number and order of networks to the create server API.

In the current implementation every instance you launch for a project having 3 networks assigned to it will always have 3 vnics. In this case it is not possible to have one instance with 2 vnics ,another with 1 vnic and so on. This is not flexible enough and the network resources are not used effectively.

2) Specify fixed IP address to the vnic at the boot time. When you launch a server, you can specify the fixed IP address you want to be assigned to the vnic from a particular network. If this fixed IP address is already in use, it will give exception.

Example of Server Create API request XML:
<?xml version="1.0" encoding="UTF-8"?>

<server xmlns="http://docs.nttpflab.com/servers/api/v1.0"
        name="new-server-test" imageId="1" flavorId="1">
  <metadata>
    <meta key="My Server Name">Apache1</meta>
  </metadata>
  <personality>
    <file path="/etc/banner.txt">
        ICAgICAgDQoiQSBjbG91ZCBkb2VzIG5vdCBrbm93IHdoeSBp
    </file>
  </personality>
  <networks>
      <network uuid="6622436e-5289-460f-8479-e4dcc63f16c5" fixed_ip="10.0.0.3">
      <network uuid="d97efefc-e071-4174-b6dd-b33af0a37706" fixed_ip="10.0.1.3">
  </networks>
</server>

3) Networks is an optional parameter, so if you don't provide any networks to the server Create API, it will behave exactly the same as of today.

This feature is supported to all of the network models.

16 files changed, 1050 insertions, 52 deletions

diff --git a/nova/api/openstack/contrib/createserverext.py b/nova/api/openstack/contrib/createserverext.py
new file mode 100644
index 000000000..ba72fdb0b
--- /dev/null
+++ b/nova/api/openstack/contrib/createserverext.py
@@ -0,0 +1,66 @@
+# 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 nova.api.openstack import create_instance_helper as helper
+from nova.api.openstack import extensions
+from nova.api.openstack import servers
+from nova.api.openstack import wsgi
+
+
+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-create-server-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/createserverext/api/v1.1"
+
+    def get_updated(self):
+        return "2011-07-19T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = []
+
+        headers_serializer = servers.HeadersSerializer()
+        body_serializers = {
+            'application/xml': servers.ServerXMLSerializer(),
+        }
+
+        body_deserializers = {
+            'application/xml': helper.ServerXMLDeserializerV11(),
+        }
+
+        serializer = wsgi.ResponseSerializer(body_serializers,
+                                             headers_serializer)
+        deserializer = wsgi.RequestDeserializer(body_deserializers)
+
+        res = extensions.ResourceExtension('os-create-server-ext',
+                                        controller=servers.ControllerV11(),
+                                        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 339f260b9..4b4a1b0c3 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -29,7 +29,7 @@ from nova import utils
 from nova.compute import instance_types
 from nova.api.openstack import common
 from nova.api.openstack import wsgi
-
+from nova.rpc.common import RemoteError
 
 LOG = logging.getLogger('nova.api.openstack.create_instance_helper')
 FLAGS = flags.FLAGS
@@ -120,6 +120,11 @@ class CreateInstanceHelper(object):
 
         sg_names = list(set(sg_names))
 
+        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:
@@ -175,6 +180,7 @@ class CreateInstanceHelper(object):
                                   reservation_id=reservation_id,
                                   min_count=min_count,
                                   max_count=max_count,
+                                  requested_networks=requested_networks,
                                   security_group=sg_names,
                                   user_data=user_data,
                                   availability_zone=availability_zone))
@@ -188,6 +194,10 @@ class CreateInstanceHelper(object):
             raise exc.HTTPBadRequest(explanation=msg)
         except exception.SecurityGroupNotFound as error:
             raise exc.HTTPBadRequest(explanation=unicode(error))
+        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):
@@ -316,6 +326,46 @@ 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_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
+                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_uuid:
+                        expl = _("Duplicate networks (%s) are not allowed")\
+                                % network_uuid
+                        raise exc.HTTPBadRequest(explanation=expl)
+
+                networks.append((network_uuid, address))
+            except KeyError as key:
+                expl = _('Bad network format: missing %s') % key
+                raise exc.HTTPBadRequest(explanation=expl)
+            except TypeError:
+                expl = _('Bad networks format')
+                raise exc.HTTPBadRequest(explanation=expl)
+
+        return networks
+
 
 class ServerXMLDeserializer(wsgi.XMLDeserializer):
     """
@@ -480,6 +530,10 @@ class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer):
         if personality is not None:
             server["personality"] = personality
 
+        networks = self._extract_networks(server_node)
+        if networks is not None:
+            server["networks"] = networks
+
         security_groups = self._extract_security_groups(server_node)
         if security_groups is not None:
             server["security_groups"] = security_groups
@@ -501,6 +555,23 @@ class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer):
         else:
             return None
 
+    def _extract_networks(self, server_node):
+        """Marshal the networks attribute of a parsed request"""
+        node = self.find_first_child_named(server_node, "networks")
+        if node is not None:
+            networks = []
+            for network_node in self.find_children_named(node,
+                                                         "network"):
+                item = {}
+                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)
+            return networks
+        else:
+            return None
+
     def _extract_security_groups(self, server_node):
         """Marshal the security_groups attribute of a parsed request"""
         node = self.find_first_child_named(server_node, "security_groups")
diff --git a/nova/compute/api.py b/nova/compute/api.py
index d3cce8568..7de91584f 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -146,6 +146,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,
@@ -153,7 +163,8 @@ class API(base.Base):
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata=None,
                injected_files=None, admin_password=None, zone_blob=None,
-               reservation_id=None, access_ip_v4=None, access_ip_v6=None):
+               reservation_id=None, access_ip_v4=None, access_ip_v6=None,
+               requested_networks=None):
         """Verify all the input parameters regardless of the provisioning
         strategy being performed."""
 
@@ -182,6 +193,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)
@@ -400,9 +412,9 @@ class API(base.Base):
     def _ask_scheduler_to_create_instance(self, context, base_options,
                                           instance_type, zone_blob,
                                           availability_zone, injected_files,
-                                          admin_password,
-                                          image,
-                                          instance_id=None, num_instances=1):
+                                          admin_password, image,
+                                          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
@@ -430,7 +442,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,
@@ -440,7 +453,8 @@ class API(base.Base):
                availability_zone=None, user_data=None, metadata=None,
                injected_files=None, admin_password=None, zone_blob=None,
                reservation_id=None, block_device_mapping=None,
-               access_ip_v4=None, access_ip_v6=None):
+               access_ip_v4=None, access_ip_v6=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."""
@@ -456,14 +470,15 @@ class API(base.Base):
                                key_name, key_data, security_group,
                                availability_zone, user_data, metadata,
                                injected_files, admin_password, zone_blob,
-                               reservation_id, access_ip_v4, access_ip_v6)
+                               reservation_id, access_ip_v4, access_ip_v6,
+                               requested_networks)
 
         self._ask_scheduler_to_create_instance(context, base_options,
                                       instance_type, zone_blob,
                                       availability_zone, injected_files,
-                                      admin_password,
-                                      image,
-                                      num_instances=num_instances)
+                                      admin_password, image,
+                                      num_instances=num_instances,
+                                      requested_networks=requested_networks)
 
         return base_options['reservation_id']
 
@@ -475,7 +490,8 @@ class API(base.Base):
                availability_zone=None, user_data=None, metadata=None,
                injected_files=None, admin_password=None, zone_blob=None,
                reservation_id=None, block_device_mapping=None,
-               access_ip_v4=None, access_ip_v6=None):
+               access_ip_v4=None, access_ip_v6=None,
+               requested_networks=None):
         """
         Provision the instances by sending off a series of single
         instance requests to the Schedulers. This is fine for trival
@@ -499,7 +515,8 @@ class API(base.Base):
                                key_name, key_data, security_group,
                                availability_zone, user_data, metadata,
                                injected_files, admin_password, zone_blob,
-                               reservation_id, access_ip_v4, access_ip_v6)
+                               reservation_id, access_ip_v4, access_ip_v6,
+                               requested_networks)
 
         block_device_mapping = block_device_mapping or []
         instances = []
@@ -513,11 +530,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,
-                                          image,
-                                          instance_id=instance_id)
+                                        instance_type, zone_blob,
+                                        availability_zone, injected_files,
+                                        admin_password, image,
+                                        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 091b3b6b2..c207eccbb 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -382,6 +382,8 @@ class ComputeManager(manager.SchedulerDependentManager):
         context = context.elevated()
         instance = self.db.instance_get(context, instance_id)
 
+        requested_networks = kwargs.get('requested_networks', None)
+
         if instance['name'] in self.driver.list_instances():
             raise exception.Error(_("Instance has already been created"))
 
@@ -411,7 +413,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)
             else:
                 # TODO(tr3buchet) not really sure how this should be handled.
diff --git a/nova/db/api.py b/nova/db/api.py
index e946e8436..2d854f24c 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):
@@ -396,7 +396,6 @@ def fixed_ip_update(context, address, values):
     """Create a fixed ip from the values dictionary."""
     return IMPL.fixed_ip_update(context, address, values)
 
-
 ####################
 
 
@@ -686,7 +685,14 @@ def network_get_all(context):
     return IMPL.network_get_all(context)
 
 
+def network_get_all_by_uuids(context, network_uuids, project_id=None):
+    """Return networks by ids."""
+    return IMPL.network_get_all_by_uuids(context, network_uuids, project_id)
+
+
 # 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)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 0f747c602..04b5405f6 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -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
@@ -1755,6 +1768,40 @@ def network_get_all(context):
     return result
 
 
+@require_admin_context
+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()
+
+    #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_uuid in network_uuids:
+        found = False
+        for network in result:
+            if network['uuid'] == network_uuid:
+                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
+
 # 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
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/040_add_uuid_to_networks.py b/nova/db/sqlalchemy/migrate_repo/versions/040_add_uuid_to_networks.py
new file mode 100644
index 000000000..38c543d51
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/040_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 a487ab28d..19dc3302e 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -561,6 +561,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 e8cb7bcb5..66740019b 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -423,6 +423,15 @@ class NoNetworksFound(NotFound):
     message = _("No networks defined.")
 
 
+class NetworkNotFoundForProject(NotFound):
+    message = _("Either Network uuid %(network_uuid)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.")
 
@@ -456,6 +465,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_uuid)s).")
+
+
+class FixedIpAlreadyInUse(NovaException):
+    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 247768722..d04474df3 100644
--- a/nova/network/api.py
+++ b/nova/network/api.py
@@ -195,3 +195,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 921c27e45..aa2a3700c 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -131,7 +131,15 @@ class RPCAllocateFixedIP(object):
         green_pool = greenpool.GreenPool()
 
         vpn = kwargs.pop('vpn')
+        requested_networks = kwargs.pop('requested_networks')
+
         for network in networks:
+            address = None
+            if requested_networks is not None:
+                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
             if not network['multi_host']:
                 host = network['host']
@@ -148,6 +156,7 @@ class RPCAllocateFixedIP(object):
                 args = {}
                 args['instance_id'] = instance_id
                 args['network_id'] = network['id']
+                args['address'] = address
                 args['vpn'] = vpn
 
                 green_pool.spawn_n(rpc.call, context, topic,
@@ -155,7 +164,8 @@ class RPCAllocateFixedIP(object):
                                     'args': args})
             else:
                 # i am the correct host, run here
-                self.allocate_fixed_ip(context, instance_id, network, vpn=vpn)
+                self.allocate_fixed_ip(context, instance_id, network,
+                                       vpn=vpn, address=address)
 
         # wait for all of the allocates (if any) to finish
         green_pool.waitall()
@@ -199,6 +209,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()
@@ -380,16 +391,21 @@ class NetworkManager(manager.SchedulerDependentManager):
         self.compute_api.trigger_security_group_members_refresh(admin_context,
                                                                     group_ids)
 
-    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
-        try:
-            networks = self.db.network_get_all(context)
-        except exception.NoNetworksFound:
-            return []
-
+        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_all_by_uuids(context,
+                                                    network_uuids)
+        else:
+            try:
+                networks = self.db.network_get_all(context)
+            except exception.NoNetworksFound:
+                return []
         # return only networks which are not vlan networks
         return [network for network in networks if
                 not network['vlan']]
@@ -403,16 +419,18 @@ class NetworkManager(manager.SchedulerDependentManager):
         host = kwargs.pop('host')
         project_id = kwargs.pop('project_id')
         type_id = kwargs.pop('instance_type_id')
+        requested_networks = kwargs.get('requested_networks')
         vpn = kwargs.pop('vpn')
         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)
-        LOG.warn(networks)
+        networks = self._get_networks_for_instance(admin_context,
+                                        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)
+        self._allocate_fixed_ips(admin_context, instance_id,
+                                 host, networks, vpn=vpn,
+                                 requested_networks=requested_networks)
         return self.get_instance_nw_info(context, instance_id, type_id, host)
 
     def deallocate_for_instance(self, context, **kwargs):
@@ -570,9 +588,15 @@ class NetworkManager(manager.SchedulerDependentManager):
         #             network_get_by_compute_host
         address = None
         if network['cidr']:
-            address = self.db.fixed_ip_associate_pool(context.elevated(),
-                                                      network['id'],
-                                                      instance_id)
+            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
@@ -798,6 +822,35 @@ class NetworkManager(manager.SchedulerDependentManager):
         """Sets up network on this host."""
         raise NotImplementedError()
 
+    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._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 address 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)
+
 
 class FlatManager(NetworkManager):
     """Basic network where no vlans are used.
@@ -832,8 +885,16 @@ class FlatManager(NetworkManager):
     def _allocate_fixed_ips(self, context, instance_id, host, networks,
                             **kwargs):
         """Calls allocate_fixed_ip once for each network."""
+        requested_networks = kwargs.pop('requested_networks')
         for network in networks:
-            self.allocate_fixed_ip(context, instance_id, network)
+            address = None
+            if requested_networks is not None:
+                for address in (fixed_ip for (uuid, fixed_ip) in \
+                              requested_networks if network['uuid'] == uuid):
+                    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."""
@@ -927,9 +988,15 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
                                        address,
                                        instance_id)
         else:
-            address = self.db.fixed_ip_associate_pool(context,
-                                                      network['id'],
-                                                      instance_id)
+            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,
@@ -945,10 +1012,18 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
         """Force adds another network to a project."""
         self.db.network_associate(context, project_id, force=True)
 
-    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
-        return self.db.project_get_networks(context, project_id)
+        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_all_by_uuids(context,
+                                                    network_uuids,
+                                                    project_id)
+        else:
+            networks = self.db.project_get_networks(context, project_id)
+        return networks
 
     def create_networks(self, context, **kwargs):
         """Create networks based on parameters."""
@@ -997,6 +1072,10 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
                 self.db.network_update(context, network_ref['id'],
                                        {'gateway_v6': gateway})
 
+    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):
         """Number of reserved ips at the bottom of the range."""
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..e5eed14fe
--- /dev/null
+++ b/nova/tests/api/openstack/contrib/test_createserverext.py
@@ -0,0 +1,306 @@
+# 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'
+
+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):
+
+    def setUp(self):
+        super(CreateserverextTest, self).setUp()
+        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,
+                         'created_at': "",
+                         'updated_at': ""}]
+
+            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(
+            nova.api.openstack.create_instance_helper.CreateInstanceHelper,
+            '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
+        return compute_api
+
+    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 uuid, fixed_ip in networks:
+                network_list.append({'uuid': uuid, '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/123/os-create-server-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([
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.1"',
+            ' name="%s" imageRef="%s" flavorRef="%s">' % (
+                    server['name'], server['imageRef'], server['flavorRef'])])
+        if 'metadata' in server:
+            metadata = server['metadata']
+            body_parts.append('<metadata>')
+            for item in metadata.iteritems():
+                body_parts.append('<meta key="%s">%s</meta>' % item)
+            body_parts.append('</metadata>')
+        if 'personality' in server:
+            personalities = server['personality']
+            body_parts.append('<personality>')
+            for file in personalities:
+                item = (file['path'], file['contents'])
+                body_parts.append('<file path="%s">%s</file>' % item)
+            body_parts.append('</personality>')
+        if 'networks' in server:
+            networks = server['networks']
+            body_parts.append('<networks>')
+            for network in networks:
+                item = (network['uuid'], network['fixed_ip'])
+                body_parts.append('<network uuid="%s" fixed_ip="%s"></network>'
+                                  % item)
+            body_parts.append('</networks>')
+        body_parts.append('</server>')
+        return ''.join(body_parts)
+
+    def _get_create_request_xml(self, body_dict):
+        req = webob.Request.blank('/v1.1/123/os-create-server-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_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_networks(self):
+        request, response, networks = \
+                self._create_instance_with_networks_json(networks=None)
+        self.assertEquals(response.status_int, 202)
+        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, 202)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_one_network(self):
+        request, response, networks = \
+            self._create_instance_with_networks_json([FAKE_NETWORKS[0]])
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, [FAKE_NETWORKS[0]])
+
+    def test_create_instance_with_one_network_xml(self):
+        request, response, networks = \
+            self._create_instance_with_networks_xml([FAKE_NETWORKS[0]])
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, [FAKE_NETWORKS[0]])
+
+    def test_create_instance_with_two_networks(self):
+        request, response, networks = \
+            self._create_instance_with_networks_json(FAKE_NETWORKS)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, FAKE_NETWORKS)
+
+    def test_create_instance_with_two_networks_xml(self):
+        request, response, networks = \
+            self._create_instance_with_networks_xml(FAKE_NETWORKS)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, FAKE_NETWORKS)
+
+    def test_create_instance_with_duplicate_networks(self):
+        request, response, 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):
+        request, response, 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):
+        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)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.networks, None)
+
+    def test_create_instance_with_network_no_id_xml(self):
+        body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]])
+        request = self._get_create_request_xml(body_dict)
+        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):
+        request, response, 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):
+        request, response, networks = \
+            self._create_instance_with_networks_xml(INVALID_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):
+        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,
+                          [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', None)])
+
+    def test_create_instance_with_network_no_fixed_ip_xml(self):
+        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,
+                          [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', None)])
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 4060763fc..9f923852d 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -85,6 +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",
             "FlavorExtraSpecs",
             "Floating_ips",
             "Fox In Socks",
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 800a2e229..dd4b63a2c 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -1890,6 +1890,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_server_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
@@ -2829,6 +2852,164 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
         }
         self.assertEquals(request['body'], expected)
 
+    def test_request_with_empty_networks(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks/>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": []
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1" fixed_ip="10.0.1.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_two_networks(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1" fixed_ip="10.0.1.12"/>
+       <network uuid="2" fixed_ip="10.0.2.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"},
+                             {"uuid": "2", "fixed_ip": "10.0.2.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_second_network_node_ignored(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1" fixed_ip="10.0.1.12"/>
+    </networks>
+    <networks>
+       <network uuid="2" fixed_ip="10.0.2.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network_missing_id(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network fixed_ip="10.0.1.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "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 = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network_empty_id(self):
+        serial_request = """
+    <server xmlns="http://docs.openstack.org/compute/api/v1.1"
+     name="new-server-test" imageRef="1" flavorRef="1">
+        <networks>
+           <network uuid="" fixed_ip="10.0.1.12"/>
+        </networks>
+    </server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "", "fixed_ip": "10.0.1.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network_empty_fixed_ip(self):
+        serial_request = """
+    <server xmlns="http://docs.openstack.org/compute/api/v1.1"
+     name="new-server-test" imageRef="1" flavorRef="1">
+        <networks>
+           <network uuid="1" fixed_ip=""/>
+        </networks>
+    </server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": ""}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_networks_duplicate_ids(self):
+        serial_request = """
+    <server xmlns="http://docs.openstack.org/compute/api/v1.1"
+     name="new-server-test" imageRef="1" flavorRef="1">
+        <networks>
+           <network uuid="1" fixed_ip="10.0.1.12"/>
+           <network uuid="1" fixed_ip="10.0.2.12"/>
+        </networks>
+    </server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"},
+                             {"uuid": "1", "fixed_ip": "10.0.2.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
 
 class TestAddressesXMLSerialization(test.TestCase):
 
@@ -2899,12 +3080,14 @@ class TestServerInstanceCreation(test.TestCase):
 
             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
+
                 return [{'id': '1234', 'display_name': 'fakeinstance',
                          'uuid': FAKE_UUID}]
 
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index e5c80b6f6..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
@@ -41,6 +42,7 @@ class FakeModel(dict):
 
 
 networks = [{'id': 0,
+             'uuid': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
              'label': 'test0',
              'injected': False,
              'multi_host': False,
@@ -60,6 +62,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,
@@ -126,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')
@@ -183,12 +188,73 @@ 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_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_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+
+        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(self.context, requested_networks)
+
+    def test_validate_networks_none_requested_networks(self):
+        self.network.validate_networks(self.context, None)
+
+    def test_validate_networks_empty_requested_networks(self):
+        requested_networks = []
+        self.mox.ReplayAll()
+
+        self.network.validate_networks(self.context, requested_networks)
+
+    def test_validate_networks_invalid_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+        requested_networks = [(1, "192.168.0.100.1")]
+        db.network_get_all_by_uuids(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_all_by_uuids')
+
+        requested_networks = [(1, "")]
+        db.network_get_all_by_uuids(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_all_by_uuids')
+
+        requested_networks = [(1, None)]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                    mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+
+        self.network.validate_networks(None, requested_networks)
+
 
 class VlanNetworkTestCase(test.TestCase):
     def setUp(self):
         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')
@@ -232,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,
@@ -243,6 +309,68 @@ class VlanNetworkTestCase(test.TestCase):
                           num_networks=100, vlan_start=1,
                           cidr='192.168.0.1/24', network_size=100)
 
+    def test_validate_networks(self):
+        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_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+
+        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(self.context, requested_networks)
+
+    def test_validate_networks_none_requested_networks(self):
+        self.network.validate_networks(self.context, None)
+
+    def test_validate_networks_empty_requested_networks(self):
+        requested_networks = []
+        self.mox.ReplayAll()
+
+        self.network.validate_networks(self.context, requested_networks)
+
+    def test_validate_networks_invalid_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+        requested_networks = [(1, "192.168.0.100.1")]
+        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, self.context,
+                          requested_networks)
+
+    def test_validate_networks_empty_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+
+        requested_networks = [(1, "")]
+        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,
+                          self.context, requested_networks)
+
+    def test_validate_networks_none_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+
+        requested_networks = [(1, None)]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+        self.network.validate_networks(self.context, requested_networks)
+
 
 class CommonNetworkTestCase(test.TestCase):
 
diff --git a/nova/utils.py b/nova/utils.py
index f6e98c2eb..fc4bbd53b 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -844,3 +844,19 @@ def bool_from_str(val):
         return True if int(val) else False
     except ValueError:
         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