Fix error on querying neutron quota

[sdnvpn.git] / sdnvpn / lib / utils.py

diff --git a/sdnvpn/lib/utils.py b/sdnvpn/lib/utils.py
index 9f4c883..9a5e181 100644 (file)
--- a/sdnvpn/lib/utils.py
+++ b/sdnvpn/lib/utils.py
@@ -15,6 +15,7 @@ import requests
 import re
 import subprocess
 from concurrent.futures import ThreadPoolExecutor
 import re
 import subprocess
 from concurrent.futures import ThreadPoolExecutor

+from openstack.exceptions import ResourceNotFound

 from requests.auth import HTTPBasicAuth
 
 from opnfv.deployment.factory import Factory as DeploymentFactory
 from requests.auth import HTTPBasicAuth
 
 from opnfv.deployment.factory import Factory as DeploymentFactory


@@ -66,9 +67,9 @@ def create_custom_flavor():
                                          common_config.custom_flavor_vcpus)
 
 
                                          common_config.custom_flavor_vcpus)
 
 

-def create_net(neutron_client, name):
+def create_net(conn, name):

     logger.debug("Creating network %s", name)
     logger.debug("Creating network %s", name)

-    net_id = os_utils.create_neutron_net(neutron_client, name)
+    net_id = os_utils.create_neutron_net(conn, name)

     if not net_id:
         logger.error(
             "There has been a problem when creating the neutron network")
     if not net_id:
         logger.error(
             "There has been a problem when creating the neutron network")


@@ -77,10 +78,10 @@ def create_net(neutron_client, name):
     return net_id
 
 
     return net_id
 
 

-def create_subnet(neutron_client, name, cidr, net_id):
+def create_subnet(conn, name, cidr, net_id):

     logger.debug("Creating subnet %s in network %s with cidr %s",
                  name, net_id, cidr)
     logger.debug("Creating subnet %s in network %s with cidr %s",
                  name, net_id, cidr)

-    subnet_id = os_utils.create_neutron_subnet(neutron_client,
+    subnet_id = os_utils.create_neutron_subnet(conn,

                                                name,
                                                cidr,
                                                net_id)
                                                name,
                                                cidr,
                                                net_id)


@@ -92,12 +93,12 @@ def create_subnet(neutron_client, name, cidr, net_id):
     return subnet_id
 
 
     return subnet_id
 
 

-def create_network(neutron_client, net, subnet1, cidr1,
+def create_network(conn, net, subnet1, cidr1,

                    router, subnet2=None, cidr2=None):
     """Network assoc won't work for networks/subnets created by this function.
     It is an ODL limitation due to it handling routers as vpns.
     See https://bugs.opendaylight.org/show_bug.cgi?id=6962"""
                    router, subnet2=None, cidr2=None):
     """Network assoc won't work for networks/subnets created by this function.
     It is an ODL limitation due to it handling routers as vpns.
     See https://bugs.opendaylight.org/show_bug.cgi?id=6962"""

-    network_dic = os_utils.create_network_full(neutron_client,
+    network_dic = os_utils.create_network_full(conn,

                                                net,
                                                subnet1,
                                                router,
                                                net,
                                                subnet1,
                                                router,


@@ -114,7 +115,7 @@ def create_network(neutron_client, net, subnet1, cidr1,
     if subnet2 is not None:
         logger.debug("Creating and attaching a second subnet...")
         subnet_id = os_utils.create_neutron_subnet(
     if subnet2 is not None:
         logger.debug("Creating and attaching a second subnet...")
         subnet_id = os_utils.create_neutron_subnet(

-            neutron_client, subnet2, cidr2, net_id)
+            conn, subnet2, cidr2, net_id)

         if not subnet_id:
             logger.error(
                 "There has been a problem when creating the second subnet")
         if not subnet_id:
             logger.error(
                 "There has been a problem when creating the second subnet")


@@ -124,16 +125,15 @@ def create_network(neutron_client, net, subnet1, cidr1,
     return net_id, subnet_id, router_id
 
 
     return net_id, subnet_id, router_id
 
 

-def get_port(neutron_client, instance_id):
-    ports = os_utils.get_port_list(neutron_client)
-    if ports is not None:
-        for port in ports:
-            if port['device_id'] == instance_id:
-                return port
+def get_port(conn, instance_id):
+    ports = os_utils.get_port_list(conn)
+    for port in ports:
+        if port.device_id == instance_id:
+            return port

     return None
 
 
     return None
 
 

-def update_port_allowed_address_pairs(neutron_client, port_id, address_pairs):
+def update_port_allowed_address_pairs(conn, port_id, address_pairs):

     if len(address_pairs) <= 0:
         return
     allowed_address_pairs = []
     if len(address_pairs) <= 0:
         return
     allowed_address_pairs = []


@@ -141,30 +141,27 @@ def update_port_allowed_address_pairs(neutron_client, port_id, address_pairs):
         address_pair_dict = {'ip_address': address_pair.ipaddress,
                              'mac_address': address_pair.macaddress}
         allowed_address_pairs.append(address_pair_dict)
         address_pair_dict = {'ip_address': address_pair.ipaddress,
                              'mac_address': address_pair.macaddress}
         allowed_address_pairs.append(address_pair_dict)

-    json_body = {'port': {
-        "allowed_address_pairs": allowed_address_pairs
-    }}

 
     try:
 
     try:

-        port = neutron_client.update_port(port=port_id,
-                                          body=json_body)
-        return port['port']['id']
+        port = conn.network.\
+            update_port(port_id, allowed_address_pairs=allowed_address_pairs)
+        return port.id

     except Exception as e:
     except Exception as e:

-        logger.error("Error [update_neutron_port(neutron_client, '%s', '%s')]:"
+        logger.error("Error [update_neutron_port(network, '%s', '%s')]:"

                      " %s" % (port_id, address_pairs, e))
         return None
 
 
                      " %s" % (port_id, address_pairs, e))
         return None
 
 

-def create_instance(nova_client,
+def create_instance(conn,

                     name,
                     image_id,
                     network_id,
                     sg_id,
                     secgroup_name=None,
                     fixed_ip=None,
                     name,
                     image_id,
                     network_id,
                     sg_id,
                     secgroup_name=None,
                     fixed_ip=None,

-                    compute_node='',
+                    compute_node=None,

                     userdata=None,
                     userdata=None,

-                    files=None,
+                    files=[],

                     **kwargs
                     ):
     if 'flavor' not in kwargs:
                     **kwargs
                     ):
     if 'flavor' not in kwargs:


@@ -192,10 +189,12 @@ def create_instance(nova_client,
         logger.error("Error while booting instance.")
         raise Exception("Error while booting instance {}".format(name))
     else:
         logger.error("Error while booting instance.")
         raise Exception("Error while booting instance {}".format(name))
     else:

+        # Retrieve IP of INSTANCE
+        network_name = conn.network.get_network(network_id).name
+        instance_ip = conn.compute.get_server(instance).\
+            addresses.get(network_name)[0]['addr']

         logger.debug("Instance '%s' booted successfully. IP='%s'." %
         logger.debug("Instance '%s' booted successfully. IP='%s'." %

-                     (name, instance.networks.itervalues().next()[0]))
-    # Retrieve IP of INSTANCE
-    # instance_ip = instance.networks.get(network_id)[0]
+                     (name, instance_ip))

 
     if secgroup_name:
         logger.debug("Adding '%s' to security group '%s'..."
 
     if secgroup_name:
         logger.debug("Adding '%s' to security group '%s'..."


@@ -203,7 +202,7 @@ def create_instance(nova_client,
     else:
         logger.debug("Adding '%s' to security group '%s'..."
                      % (name, sg_id))
     else:
         logger.debug("Adding '%s' to security group '%s'..."
                      % (name, sg_id))

-    os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
+    os_utils.add_secgroup_to_instance(conn, instance.id, sg_id)

 
     return instance
 
 
     return instance
 


@@ -321,18 +320,21 @@ def get_installer_ip():
     return str(os.environ['INSTALLER_IP'])
 
 
     return str(os.environ['INSTALLER_IP'])
 
 

-def get_instance_ip(instance):
-    instance_ip = instance.networks.itervalues().next()[0]
+def get_instance_ip(conn, instance):
+    instance_ip = conn.compute.get_server(instance).\
+        addresses.values()[0][0]['addr']

     return instance_ip
 
 
 def wait_for_instance(instance, pattern=".* login:", tries=40):
     logger.info("Waiting for instance %s to boot up" % instance.id)
     return instance_ip
 
 
 def wait_for_instance(instance, pattern=".* login:", tries=40):
     logger.info("Waiting for instance %s to boot up" % instance.id)

+    conn = os_utils.get_os_connection()

     sleep_time = 2
     expected_regex = re.compile(pattern)
     console_log = ""
     while tries > 0 and not expected_regex.search(console_log):
     sleep_time = 2
     expected_regex = re.compile(pattern)
     console_log = ""
     while tries > 0 and not expected_regex.search(console_log):

-        console_log = instance.get_console_output()
+        console_log = conn.compute.\
+            get_server_console_output(instance)['output']

         time.sleep(sleep_time)
         tries -= 1
 
         time.sleep(sleep_time)
         tries -= 1
 


@@ -371,14 +373,14 @@ def async_Wait_for_instances(instances, tries=40):
         logger.error("one or more instances is not yet booted up")
 
 
         logger.error("one or more instances is not yet booted up")
 
 

-def wait_for_instance_delete(nova_client, instance_id, tries=30):
+def wait_for_instance_delete(conn, instance_id, tries=30):

     sleep_time = 2
     instances = [instance_id]
     logger.debug("Waiting for instance %s to be deleted"
                  % (instance_id))
     while tries > 0 and instance_id in instances:
         instances = [instance.id for instance in
     sleep_time = 2
     instances = [instance_id]
     logger.debug("Waiting for instance %s to be deleted"
                  % (instance_id))
     while tries > 0 and instance_id in instances:
         instances = [instance.id for instance in

-                     os_utils.get_instances(nova_client)]
+                     os_utils.get_instances(conn)]

         time.sleep(sleep_time)
         tries -= 1
     if instance_id in instances:
         time.sleep(sleep_time)
         tries -= 1
     if instance_id in instances:


@@ -441,10 +443,10 @@ def wait_before_subtest(*args, **kwargs):
     time.sleep(30)
 
 
     time.sleep(30)
 
 

-def assert_and_get_compute_nodes(nova_client, required_node_number=2):
+def assert_and_get_compute_nodes(conn, required_node_number=2):

     """Get the compute nodes in the deployment
     Exit if the deployment doesn't have enough compute nodes"""
     """Get the compute nodes in the deployment
     Exit if the deployment doesn't have enough compute nodes"""

-    compute_nodes = os_utils.get_hypervisors(nova_client)
+    compute_nodes = os_utils.get_hypervisors(conn)

 
     num_compute_nodes = len(compute_nodes)
     if num_compute_nodes < 2:
 
     num_compute_nodes = len(compute_nodes)
     if num_compute_nodes < 2:


@@ -459,13 +461,13 @@ def assert_and_get_compute_nodes(nova_client, required_node_number=2):
     return compute_nodes
 
 
     return compute_nodes
 
 

-def open_icmp(neutron_client, security_group_id):
-    if os_utils.check_security_group_rules(neutron_client,
+def open_icmp(conn, security_group_id):
+    if os_utils.check_security_group_rules(conn,

                                            security_group_id,
                                            'ingress',
                                            'icmp'):
 
                                            security_group_id,
                                            'ingress',
                                            'icmp'):
 

-        if not os_utils.create_secgroup_rule(neutron_client,
+        if not os_utils.create_secgroup_rule(conn,

                                              security_group_id,
                                              'ingress',
                                              'icmp'):
                                              security_group_id,
                                              'ingress',
                                              'icmp'):


@@ -475,14 +477,14 @@ def open_icmp(neutron_client, security_group_id):
                     % security_group_id)
 
 
                     % security_group_id)
 
 

-def open_http_port(neutron_client, security_group_id):
-    if os_utils.check_security_group_rules(neutron_client,
+def open_http_port(conn, security_group_id):
+    if os_utils.check_security_group_rules(conn,

                                            security_group_id,
                                            'ingress',
                                            'tcp',
                                            80, 80):
 
                                            security_group_id,
                                            'ingress',
                                            'tcp',
                                            80, 80):
 

-        if not os_utils.create_secgroup_rule(neutron_client,
+        if not os_utils.create_secgroup_rule(conn,

                                              security_group_id,
                                              'ingress',
                                              'tcp',
                                              security_group_id,
                                              'ingress',
                                              'tcp',


@@ -494,14 +496,14 @@ def open_http_port(neutron_client, security_group_id):
                     % security_group_id)
 
 
                     % security_group_id)
 
 

-def open_bgp_port(neutron_client, security_group_id):
-    if os_utils.check_security_group_rules(neutron_client,
+def open_bgp_port(conn, security_group_id):
+    if os_utils.check_security_group_rules(conn,

                                            security_group_id,
                                            'ingress',
                                            'tcp',
                                            179, 179):
 
                                            security_group_id,
                                            'ingress',
                                            'tcp',
                                            179, 179):
 

-        if not os_utils.create_secgroup_rule(neutron_client,
+        if not os_utils.create_secgroup_rule(conn,

                                              security_group_id,
                                              'ingress',
                                              'tcp',
                                              security_group_id,
                                              'ingress',
                                              'tcp',


@@ -561,7 +563,7 @@ def run_odl_cmd(odl_node, cmd):
     return odl_node.run_cmd(karaf_cmd)
 
 
     return odl_node.run_cmd(karaf_cmd)
 
 

-def wait_for_cloud_init(instance):
+def wait_for_cloud_init(conn, instance):

     success = True
     # ubuntu images take a long time to start
     tries = 20
     success = True
     # ubuntu images take a long time to start
     tries = 20


@@ -569,7 +571,8 @@ def wait_for_cloud_init(instance):
     logger.info("Waiting for cloud init of instance: {}"
                 "".format(instance.name))
     while tries > 0:
     logger.info("Waiting for cloud init of instance: {}"
                 "".format(instance.name))
     while tries > 0:

-        instance_log = instance.get_console_output()
+        instance_log = conn.compute.\
+            get_server_console_output(instance)['output']

         if "Failed to run module" in instance_log:
             success = False
             logger.error("Cloud init failed to run. Reason: %s",
         if "Failed to run module" in instance_log:
             success = False
             logger.error("Cloud init failed to run. Reason: %s",


@@ -592,7 +595,7 @@ def wait_for_cloud_init(instance):
 
 
 def attach_instance_to_ext_br(instance, compute_node):
 
 
 def attach_instance_to_ext_br(instance, compute_node):

-    libvirt_instance_name = getattr(instance, "OS-EXT-SRV-ATTR:instance_name")
+    libvirt_instance_name = instance.instance_name

     installer_type = str(os.environ['INSTALLER_TYPE'].lower())
     if installer_type == "fuel":
         bridge = "br-ex"
     installer_type = str(os.environ['INSTALLER_TYPE'].lower())
     if installer_type == "fuel":
         bridge = "br-ex"


@@ -621,7 +624,7 @@ def attach_instance_to_ext_br(instance, compute_node):
 
 
 def detach_instance_from_ext_br(instance, compute_node):
 
 
 def detach_instance_from_ext_br(instance, compute_node):

-    libvirt_instance_name = getattr(instance, "OS-EXT-SRV-ATTR:instance_name")
+    libvirt_instance_name = instance.instance_name

     mac = compute_node.run_cmd("for vm in $(sudo virsh list | "
                                "grep running | awk '{print $2}'); "
                                "do echo -n ; sudo virsh dumpxml $vm| "
     mac = compute_node.run_cmd("for vm in $(sudo virsh list | "
                                "grep running | awk '{print $2}'); "
                                "do echo -n ; sudo virsh dumpxml $vm| "


@@ -651,12 +654,11 @@ def detach_instance_from_ext_br(instance, compute_node):
         compute_node.run_cmd(cmd.format(bridge=bridge))
 
 
         compute_node.run_cmd(cmd.format(bridge=bridge))
 
 

-def cleanup_neutron(neutron_client, floatingip_ids, bgpvpn_ids, interfaces,
-                    subnet_ids, router_ids, network_ids):
-
+def cleanup_neutron(conn, neutron_client, floatingip_ids, bgpvpn_ids,
+                    interfaces, subnet_ids, router_ids, network_ids):

     if len(floatingip_ids) != 0:
         for floatingip_id in floatingip_ids:
     if len(floatingip_ids) != 0:
         for floatingip_id in floatingip_ids:

-            if not os_utils.delete_floating_ip(neutron_client, floatingip_id):
+            if not os_utils.delete_floating_ip(conn, floatingip_id):

                 logger.error('Fail to delete all floating ips. '
                              'Floating ip with id {} was not deleted.'.
                              format(floatingip_id))
                 logger.error('Fail to delete all floating ips. '
                              'Floating ip with id {} was not deleted.'.
                              format(floatingip_id))


@@ -668,7 +670,7 @@ def cleanup_neutron(neutron_client, floatingip_ids, bgpvpn_ids, interfaces,
 
     if len(interfaces) != 0:
         for router_id, subnet_id in interfaces:
 
     if len(interfaces) != 0:
         for router_id, subnet_id in interfaces:

-            if not os_utils.remove_interface_router(neutron_client,
+            if not os_utils.remove_interface_router(conn,

                                                     router_id, subnet_id):
                 logger.error('Fail to delete all interface routers. '
                              'Interface router with id {} was not deleted.'.
                                                     router_id, subnet_id):
                 logger.error('Fail to delete all interface routers. '
                              'Interface router with id {} was not deleted.'.


@@ -676,14 +678,14 @@ def cleanup_neutron(neutron_client, floatingip_ids, bgpvpn_ids, interfaces,
 
     if len(router_ids) != 0:
         for router_id in router_ids:
 
     if len(router_ids) != 0:
         for router_id in router_ids:

-            if not os_utils.remove_gateway_router(neutron_client, router_id):
+            if not os_utils.remove_gateway_router(conn, router_id):

                 logger.error('Fail to delete all gateway routers. '
                              'Gateway router with id {} was not deleted.'.
                              format(router_id))
 
     if len(subnet_ids) != 0:
         for subnet_id in subnet_ids:
                 logger.error('Fail to delete all gateway routers. '
                              'Gateway router with id {} was not deleted.'.
                              format(router_id))
 
     if len(subnet_ids) != 0:
         for subnet_id in subnet_ids:

-            if not os_utils.delete_neutron_subnet(neutron_client, subnet_id):
+            if not os_utils.delete_neutron_subnet(conn, subnet_id):

                 logger.error('Fail to delete all subnets. '
                              'Subnet with id {} was not deleted.'.
                              format(subnet_id))
                 logger.error('Fail to delete all subnets. '
                              'Subnet with id {} was not deleted.'.
                              format(subnet_id))


@@ -691,7 +693,7 @@ def cleanup_neutron(neutron_client, floatingip_ids, bgpvpn_ids, interfaces,
 
     if len(router_ids) != 0:
         for router_id in router_ids:
 
     if len(router_ids) != 0:
         for router_id in router_ids:

-            if not os_utils.delete_neutron_router(neutron_client, router_id):
+            if not os_utils.delete_neutron_router(conn, router_id):

                 logger.error('Fail to delete all routers. '
                              'Router with id {} was not deleted.'.
                              format(router_id))
                 logger.error('Fail to delete all routers. '
                              'Router with id {} was not deleted.'.
                              format(router_id))


@@ -699,7 +701,7 @@ def cleanup_neutron(neutron_client, floatingip_ids, bgpvpn_ids, interfaces,
 
     if len(network_ids) != 0:
         for network_id in network_ids:
 
     if len(network_ids) != 0:
         for network_id in network_ids:

-            if not os_utils.delete_neutron_net(neutron_client, network_id):
+            if not os_utils.delete_neutron_net(conn, network_id):

                 logger.error('Fail to delete all networks. '
                              'Network with id {} was not deleted.'.
                              format(network_id))
                 logger.error('Fail to delete all networks. '
                              'Network with id {} was not deleted.'.
                              format(network_id))


@@ -707,25 +709,25 @@ def cleanup_neutron(neutron_client, floatingip_ids, bgpvpn_ids, interfaces,
     return True
 
 
     return True
 
 

-def cleanup_nova(nova_client, instance_ids, flavor_ids=None):
+def cleanup_nova(conn, instance_ids, flavor_ids=None):

     if flavor_ids is not None and len(flavor_ids) != 0:
         for flavor_id in flavor_ids:
     if flavor_ids is not None and len(flavor_ids) != 0:
         for flavor_id in flavor_ids:

-            nova_client.flavors.delete(flavor_id)
+            conn.compute.delete_flavor(flavor_id)

     if len(instance_ids) != 0:
         for instance_id in instance_ids:
     if len(instance_ids) != 0:
         for instance_id in instance_ids:

-            if not os_utils.delete_instance(nova_client, instance_id):
+            if not os_utils.delete_instance(conn, instance_id):

                 logger.error('Fail to delete all instances. '
                              'Instance with id {} was not deleted.'.
                              format(instance_id))
             else:
                 logger.error('Fail to delete all instances. '
                              'Instance with id {} was not deleted.'.
                              format(instance_id))
             else:

-                wait_for_instance_delete(nova_client, instance_id)
+                wait_for_instance_delete(conn, instance_id)

     return True
 
 
     return True
 
 

-def cleanup_glance(glance_client, image_ids):
+def cleanup_glance(conn, image_ids):

     if len(image_ids) != 0:
         for image_id in image_ids:
     if len(image_ids) != 0:
         for image_id in image_ids:

-            if not os_utils.delete_glance_image(glance_client, image_id):
+            if not os_utils.delete_glance_image(conn, image_id):

                 logger.error('Fail to delete all images. '
                              'Image with id {} was not deleted.'.
                              format(image_id))
                 logger.error('Fail to delete all images. '
                              'Image with id {} was not deleted.'.
                              format(image_id))


@@ -805,55 +807,49 @@ def is_fail_mode_secure():
     return is_secure
 
 
     return is_secure
 
 

-def update_nw_subnet_port_quota(neutron_client, tenant_id, nw_quota,
+def update_nw_subnet_port_quota(conn, tenant_id, nw_quota,

                                 subnet_quota, port_quota, router_quota):
                                 subnet_quota, port_quota, router_quota):

-    json_body = {"quota": {
-        "network": nw_quota,
-        "subnet": subnet_quota,
-        "port": port_quota,
-        "router": router_quota
-    }}
-

     try:
     try:

-        neutron_client.update_quota(tenant_id=tenant_id,
-                                    body=json_body)
+        conn.network.update_quota(tenant_id, networks=nw_quota,
+                                  subnets=subnet_quota, ports=port_quota,
+                                  routers=router_quota)

         return True
     except Exception as e:
         return True
     except Exception as e:

-        logger.error("Error [update_nw_subnet_port_quota(neutron_client,"
+        logger.error("Error [update_nw_subnet_port_quota(network,"

                      " '%s', '%s', '%s', '%s, %s')]: %s" %
                      (tenant_id, nw_quota, subnet_quota,
                       port_quota, router_quota, e))
         return False
 
 
                      " '%s', '%s', '%s', '%s, %s')]: %s" %
                      (tenant_id, nw_quota, subnet_quota,
                       port_quota, router_quota, e))
         return False
 
 

-def update_instance_quota_class(nova_client, instances_quota):
+def update_instance_quota_class(cloud, instances_quota):

     try:
     try:

-        nova_client.quota_classes.update("default", instances=instances_quota)
+        cloud.set_compute_quotas('admin', instances=instances_quota)

         return True
     except Exception as e:
         return True
     except Exception as e:

-        logger.error("Error [update_instance_quota_class(nova_client,"
+        logger.error("Error [update_instance_quota_class(compute,"

                      " '%s' )]: %s" % (instances_quota, e))
         return False
 
 
                      " '%s' )]: %s" % (instances_quota, e))
         return False
 
 

-def get_neutron_quota(neutron_client, tenant_id):
+def get_neutron_quota(conn, tenant_id):

     try:
     try:

-        return neutron_client.show_quota(tenant_id=tenant_id)['quota']
-    except Exception as e:
-        logger.error("Error in getting neutron quota for tenant "
+        return conn.network.get_quota(tenant_id)
+    except ResourceNotFound as e:
+        logger.error("Error in getting network quota for tenant "

                      " '%s' )]: %s" % (tenant_id, e))
         raise
 
 
                      " '%s' )]: %s" % (tenant_id, e))
         raise
 
 

-def get_nova_instances_quota(nova_client):
+def get_nova_instances_quota(cloud):

     try:
     try:

-        return nova_client.quota_classes.get("default").instances
+        return cloud.get_compute_quotas('admin').instances

     except Exception as e:
         logger.error("Error in getting nova instances quota: %s" % e)
         raise
 
 
     except Exception as e:
         logger.error("Error in getting nova instances quota: %s" % e)
         raise
 
 

-def update_router_extra_route(neutron_client, router_id, extra_routes):
+def update_router_extra_route(conn, router_id, extra_routes):

     if len(extra_routes) <= 0:
         return
     routes_list = []
     if len(extra_routes) <= 0:
         return
     routes_list = []


@@ -861,26 +857,19 @@ def update_router_extra_route(neutron_client, router_id, extra_routes):
         route_dict = {'destination': extra_route.destination,
                       'nexthop': extra_route.nexthop}
         routes_list.append(route_dict)
         route_dict = {'destination': extra_route.destination,
                       'nexthop': extra_route.nexthop}
         routes_list.append(route_dict)

-    json_body = {'router': {
-        "routes": routes_list
-    }}

 
     try:
 
     try:

-        neutron_client.update_router(router_id, body=json_body)
+        conn.network.update_router(router_id, routes=routes_list)

         return True
     except Exception as e:
         logger.error("Error in updating router with extra route: %s" % e)
         raise
 
 
         return True
     except Exception as e:
         logger.error("Error in updating router with extra route: %s" % e)
         raise
 
 

-def update_router_no_extra_route(neutron_client, router_ids):
-    json_body = {'router': {
-        "routes": [
-        ]}}
-
+def update_router_no_extra_route(conn, router_ids):

     for router_id in router_ids:
         try:
     for router_id in router_ids:
         try:

-            neutron_client.update_router(router_id, body=json_body)
+            conn.network.update_router(router_id, routes=[])

             return True
         except Exception as e:
             logger.error("Error in clearing extra route: %s" % e)
             return True
         except Exception as e:
             logger.error("Error in clearing extra route: %s" % e)