Add example script creating an instance

This is to be used by feature projects or newcomers to functest.
SFC or BGPVPN test cases can be based on this one.
The script creates an instance and assigns a floating IP to it.

Change-Id: If35495631031187bfb5382ba8c0a8884dfaa3d7f
Signed-off-by: jose.lausuch <jose.lausuch@ericsson.com>
Depends-On: Ie10d55872bc8c5a404b0d0156ee49a9d94482008

3 files changed, 228 insertions, 22 deletions

diff --git a/ci/config_functest.yaml b/ci/config_functest.yaml
index ea502dacb..fae331d63 100644
--- a/ci/config_functest.yaml
+++ b/ci/config_functest.yaml
@@ -156,5 +156,16 @@ promise:
         subnet_cidr: 192.168.121.0/24
         router_name: promise-router
 
+example:
+    example_vm_name: example-vm
+    example_flavor: m1.small
+    example_image_name: functest-example-vm
+    example_private_net_name: example-net
+    example_private_subnet_name: example-subnet
+    example_private_subnet_cidr: 192.168.170.0/24
+    example_router_name: example-router
+    example_sg_name: example-sg
+    example_sg_descr: Example Security group
+
 results:
     test_db_url: http://testresults.opnfv.org/test/api/v1
diff --git a/testcases/OpenStack/examples/create_instance_and_ip.py b/testcases/OpenStack/examples/create_instance_and_ip.py
new file mode 100644
index 000000000..41f8a9c8a
--- /dev/null
+++ b/testcases/OpenStack/examples/create_instance_and_ip.py
@@ -0,0 +1,136 @@
+#!/usr/bin/python
+#
+# Copyright (c) 2015 All rights reserved
+# This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# This script boots an instance and assigns a floating ip
+#
+
+import argparse
+import os
+import sys
+import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_utils as ft_utils
+import functest.utils.openstack_utils as os_utils
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument("-r", "--report",
+                    help="Create json result file",
+                    action="store_true")
+
+args = parser.parse_args()
+
+""" logging configuration """
+logger = ft_logger.Logger("create_instance_and_ip").getLogger()
+
+REPO_PATH = os.environ['repos_dir'] + '/functest/'
+HOME = os.environ['HOME'] + "/"
+
+VM_BOOT_TIMEOUT = 180
+
+INSTANCE_NAME = ft_utils.get_parameter_from_yaml("example.example_vm_name")
+FLAVOR = ft_utils.get_parameter_from_yaml("example.example_flavor")
+IMAGE_NAME = ft_utils.get_parameter_from_yaml("example.example_image_name")
+IMAGE_FILENAME = ft_utils.get_parameter_from_yaml(
+    "general.openstack.image_file_name")
+IMAGE_FORMAT = ft_utils.get_parameter_from_yaml(
+    "general.openstack.image_disk_format")
+IMAGE_PATH = ft_utils.get_parameter_from_yaml(
+    "general.directories.dir_functest_data") + "/" + IMAGE_FILENAME
+
+# NEUTRON Private Network parameters
+
+NET_NAME = ft_utils.get_parameter_from_yaml(
+    "example.example_private_net_name")
+SUBNET_NAME = ft_utils.get_parameter_from_yaml(
+    "example.example_private_subnet_name")
+SUBNET_CIDR = ft_utils.get_parameter_from_yaml(
+    "example.example_private_subnet_cidr")
+ROUTER_NAME = ft_utils.get_parameter_from_yaml(
+    "example.example_router_name")
+
+SECGROUP_NAME = ft_utils.get_parameter_from_yaml(
+    "example.example_sg_name")
+SECGROUP_DESCR = ft_utils.get_parameter_from_yaml(
+    "example.example_sg_descr")
+
+TEST_DB = ft_utils.get_parameter_from_yaml("results.test_db_url")
+
+
+def main():
+
+    nova_client = os_utils.get_nova_client()
+    neutron_client = os_utils.get_neutron_client()
+    glance_client = os_utils.get_glance_client()
+
+    image_id = os_utils.create_glance_image(glance_client,
+                                            IMAGE_NAME,
+                                            IMAGE_PATH,
+                                            disk=IMAGE_FORMAT,
+                                            container="bare",
+                                            public=True,
+                                            logger=logger)
+
+    network_dic = os_utils.create_network_full(logger,
+                                               neutron_client,
+                                               NET_NAME,
+                                               SUBNET_NAME,
+                                               ROUTER_NAME,
+                                               SUBNET_CIDR)
+    if not network_dic:
+        logger.error(
+            "There has been a problem when creating the neutron network")
+        sys.exit(-1)
+
+    network_id = network_dic["net_id"]
+
+    sg_id = os_utils.create_security_group_full(logger, neutron_client,
+                                                SECGROUP_NAME, SECGROUP_DESCR)
+
+    # boot INTANCE
+    logger.info("Creating instance '%s'..." % INSTANCE_NAME)
+    logger.debug(
+        "Configuration:\n name=%s \n flavor=%s \n image=%s \n "
+        "network=%s \n" % (INSTANCE_NAME, FLAVOR, image_id, network_id))
+    instance = os_utils.create_instance_and_wait_for_active(FLAVOR,
+                                                            image_id,
+                                                            network_id,
+                                                            INSTANCE_NAME)
+
+    if instance is None:
+        logger.error("Error while booting instance.")
+        sys.exit(-1)
+    # Retrieve IP of INSTANCE
+    instance_ip = instance.networks.get(NET_NAME)[0]
+    logger.debug("Instance '%s' got private ip '%s'." %
+                 (INSTANCE_NAME, instance_ip))
+
+    logger.info("Adding '%s' to security group '%s'..."
+                % (INSTANCE_NAME, SECGROUP_NAME))
+    os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
+
+    logger.info("Creating floating IP for VM '%s'..." % INSTANCE_NAME)
+    floatip_dic = os_utils.create_floating_ip(neutron_client)
+    floatip = floatip_dic['fip_addr']
+    # floatip_id = floatip_dic['fip_id']
+
+    if floatip is None:
+        logger.error("Cannot create floating IP.")
+        sys.exit(-1)
+    logger.info("Floating IP created: '%s'" % floatip)
+
+    logger.info("Associating floating ip: '%s' to VM '%s' "
+                % (floatip, INSTANCE_NAME))
+    if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
+        logger.error("Cannot associate floating IP to VM.")
+        sys.exit(-1)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()
diff --git a/utils/openstack_utils.py b/utils/openstack_utils.py
index 9640fb9b4..1379d782d 100644
--- a/utils/openstack_utils.py
+++ b/utils/openstack_utils.py
@@ -191,9 +191,9 @@ def create_flavor(nova_client, flavor_name, ram, disk, vcpus):
 def create_instance(flavor_name,
                     image_id,
                     network_id,
-                    instance_name="",
-                    config_drive=False,
-                    userdata=""):
+                    instance_name="functest-vm",
+                    confdrive=True,
+                    userdata=None):
     nova_client = get_nova_client()
     try:
         flavor = nova_client.flavors.find(name=flavor_name)
@@ -202,14 +202,23 @@ def create_instance(flavor_name,
               flavor_name)
         print(nova_client.flavor.list())
         return -1
-
-    return nova_client.servers.create(
-        name=instance_name,
-        flavor=flavor,
-        image=image_id,
-        config_drive=config_drive,
-        nics=[{"net-id": network_id}]
-    )
+    if userdata is None:
+        instance = nova_client.servers.create(
+            name=instance_name,
+            flavor=flavor,
+            image=image_id,
+            nics=[{"net-id": network_id}]
+        )
+    else:
+        instance = nova_client.servers.create(
+            name=instance_name,
+            flavor=flavor,
+            image=image_id,
+            nics=[{"net-id": network_id}],
+            config_drive=confdrive,
+            userdata=userdata
+        )
+    return instance
 
 
 def create_instance_and_wait_for_active(flavor_name,
@@ -224,9 +233,9 @@ def create_instance_and_wait_for_active(flavor_name,
     instance = create_instance(flavor_name,
                                image_id,
                                network_id,
-                               instance_name="",
-                               config_drive=False,
-                               userdata="")
+                               instance_name,
+                               config_drive,
+                               userdata)
 
     count = VM_BOOT_TIMEOUT / SLEEP
     for n in range(count, -1, -1):
@@ -653,6 +662,46 @@ def create_secgroup_rule(neutron_client, sg_id, direction, protocol,
         return False
 
 
+def create_security_group_full(logger, neutron_client,
+                               sg_name, sg_description):
+    sg_id = get_security_group_id(neutron_client, sg_name)
+    if sg_id != '':
+        logger.info("Using existing security group '%s'..." % sg_name)
+    else:
+        logger.info("Creating security group  '%s'..." % sg_name)
+        SECGROUP = create_security_group(neutron_client,
+                                         sg_name,
+                                         sg_description)
+        if not SECGROUP:
+            logger.error("Failed to create the security group...")
+            return False
+
+        sg_id = SECGROUP['id']
+
+        logger.debug("Security group '%s' with ID=%s created successfully."
+                     % (SECGROUP['name'], sg_id))
+
+        logger.debug("Adding ICMP rules in security group '%s'..."
+                     % sg_name)
+        if not create_secgroup_rule(neutron_client, sg_id,
+                                    'ingress', 'icmp'):
+            logger.error("Failed to create the security group rule...")
+            return False
+
+        logger.debug("Adding SSH rules in security group '%s'..."
+                     % sg_name)
+        if not create_secgroup_rule(
+                neutron_client, sg_id, 'ingress', 'tcp', '22', '22'):
+            logger.error("Failed to create the security group rule...")
+            return False
+
+        if not create_secgroup_rule(
+                neutron_client, sg_id, 'egress', 'tcp', '22', '22'):
+            logger.error("Failed to create the security group rule...")
+            return False
+    return sg_id
+
+
 def add_secgroup_to_instance(nova_client, instance_id, secgroup_id):
     try:
         nova_client.servers.add_security_group(instance_id, secgroup_id)
@@ -711,18 +760,28 @@ def get_image_id(glance_client, image_name):
     return id
 
 
-def create_glance_image(glance_client, image_name, file_path, public=True):
+def create_glance_image(glance_client, image_name, file_path, disk="qcow2",
+                        container="bare", public=True, logger=None):
     if not os.path.isfile(file_path):
         print "Error: file " + file_path + " does not exist."
         return False
     try:
-        with open(file_path) as fimage:
-            image = glance_client.images.create(name=image_name,
-                                                is_public=public,
-                                                disk_format="qcow2",
-                                                container_format="bare",
-                                                data=fimage)
-        return image.id
+        image_id = get_image_id(glance_client, image_name)
+        if image_id != '':
+            if logger:
+                logger.info("Image %s already exists." % image_name)
+        else:
+            if logger:
+                logger.info("Creating image '%s' from '%s'..." % (image_name,
+                                                                  file_path))
+            with open(file_path) as fimage:
+                image = glance_client.images.create(name=image_name,
+                                                    is_public=public,
+                                                    disk_format=disk,
+                                                    container_format=container,
+                                                    data=fimage)
+            image_id = image.id
+        return image_id
     except Exception, e:
         print ("Error [create_glance_image(glance_client, '%s', '%s', "
                "'%s')]:" % (image_name, file_path, str(public))), e