add optional parameter networks to the Create server OS API

2 files changed, 156 insertions, 1 deletions

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()
@@ -772,6 +806,26 @@ def fixed_ip_get_by_address(context, address, session=None):
 
 
 @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()
     rv = session.query(models.FixedIp).\
@@ -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
@@ -2728,6 +2815,42 @@ def project_get_networks(context, project_id, associate=True):
 
 
 @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)