path: root/snaps/openstack/utils/launch_utils.py

#
# Copyright (c) 2016 Cable Television Laboratories, Inc. ("CableLabs")
#                    and others.  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.
#
# This utility makes it easy to create OpenStack objects
import logging
import re
import socket
import struct

import os
import time
from keystoneauth1.exceptions import Unauthorized

from snaps import file_utils
from snaps.config.flavor import FlavorConfig
from snaps.config.image import ImageConfig
from snaps.config.keypair import KeypairConfig
from snaps.config.network import PortConfig, NetworkConfig
from snaps.config.project import ProjectConfig
from snaps.config.qos import QoSConfig
from snaps.config.router import RouterConfig
from snaps.config.security_group import SecurityGroupConfig
from snaps.config.user import UserConfig
from snaps.config.vm_inst import VmInstanceConfig
from snaps.config.volume import VolumeConfig
from snaps.config.volume_type import VolumeTypeConfig
from snaps.openstack.create_flavor import OpenStackFlavor
from snaps.openstack.create_image import OpenStackImage
from snaps.openstack.create_keypairs import OpenStackKeypair
from snaps.openstack.create_network import OpenStackNetwork
from snaps.openstack.create_project import OpenStackProject
from snaps.openstack.create_qos import OpenStackQoS
from snaps.openstack.create_router import OpenStackRouter
from snaps.openstack.create_security_group import OpenStackSecurityGroup
from snaps.openstack.create_user import OpenStackUser
from snaps.openstack.create_volume import OpenStackVolume
from snaps.openstack.create_volume_type import OpenStackVolumeType
from snaps.openstack.os_credentials import OSCreds, ProxySettings
from snaps.openstack.utils import deploy_utils, neutron_utils, keystone_utils
from snaps.openstack.utils.nova_utils import RebootType
from snaps.provisioning import ansible_utils

logger = logging.getLogger('lanuch_utils')
DEFAULT_CREDS_KEY = 'admin'


def launch_config(config, tmplt_file, deploy, clean, clean_image):
    """
    Launches all objects and applies any configured ansible playbooks
    :param config: the environment configuration dict object
    :param tmplt_file: the path to the SNAPS-OO template file
    :param deploy: when True deploy
    :param clean: when True clean
    :param clean_image: when True clean the image when clean is True
    """
    os_config = config.get('openstack')

    creators = list()
    vm_dict = dict()
    images_dict = dict()
    flavors_dict = dict()
    networks_dict = dict()
    routers_dict = dict()
    os_creds_dict = dict()

    if os_config:
        os_creds_dict = __get_creds_dict(os_config)

        # Create projects
        projects_dict = __create_instances(
            os_creds_dict, OpenStackProject, ProjectConfig,
            os_config.get('projects'), 'project', clean)
        creators.append(projects_dict)

        # Create users
        users_dict = __create_instances(
            os_creds_dict, OpenStackUser, UserConfig,
            os_config.get('users'), 'user', clean)
        creators.append(users_dict)

        # Associate new users to projects
        if not clean:
            for project_creator in projects_dict.values():
                users = project_creator.project_settings.users
                for user_name in users:
                    user_creator = users_dict.get(user_name)
                    if user_creator:
                        project_creator.assoc_user(
                            user_creator.get_user())

        # Create flavors
        flavors_dict = __create_instances(
            os_creds_dict, OpenStackFlavor, FlavorConfig,
            os_config.get('flavors'), 'flavor', clean, users_dict)
        creators.append(flavors_dict)

        # Create QoS specs
        qos_dict = __create_instances(
            os_creds_dict, OpenStackQoS, QoSConfig,
            os_config.get('qos_specs'), 'qos_spec', clean, users_dict)
        creators.append(qos_dict)

        # Create volume types
        vol_type_dict = __create_instances(
            os_creds_dict, OpenStackVolumeType, VolumeTypeConfig,
            os_config.get('volume_types'), 'volume_type', clean,
            users_dict)
        creators.append(vol_type_dict)

        # Create volumes
        vol_dict = __create_instances(
            os_creds_dict, OpenStackVolume, VolumeConfig,
            os_config.get('volumes'), 'volume', clean, users_dict)
        creators.append(vol_dict)

        # Create images
        images_dict = __create_instances(
            os_creds_dict, OpenStackImage, ImageConfig,
            os_config.get('images'), 'image', clean, users_dict)
        creators.append(images_dict)

        # Create networks
        networks_dict = __create_instances(
            os_creds_dict, OpenStackNetwork, NetworkConfig,
            os_config.get('networks'), 'network', clean, users_dict)
        creators.append(networks_dict)

        # Create routers
        routers_dict = __create_instances(
            os_creds_dict, OpenStackRouter, RouterConfig,
            os_config.get('routers'), 'router', clean, users_dict)
        creators.append(routers_dict)

        # Create keypairs
        keypairs_dict = __create_instances(
            os_creds_dict, OpenStackKeypair, KeypairConfig,
            os_config.get('keypairs'), 'keypair', clean, users_dict)
        creators.append(keypairs_dict)

        # Create security groups
        creators.append(__create_instances(
            os_creds_dict, OpenStackSecurityGroup,
            SecurityGroupConfig,
            os_config.get('security_groups'), 'security_group', clean,
            users_dict))

        # Create instance
        vm_dict = __create_vm_instances(
            os_creds_dict, users_dict, os_config.get('instances'),
            images_dict, keypairs_dict, clean)
        creators.append(vm_dict)
        logger.info(
            'Completed creating/retrieving all configured instances')

    # Must enter either block
    if clean:
        # Cleanup Environment
        __cleanup(creators, clean_image)
    elif deploy:
        # Provision VMs
        ansible_config = config.get('ansible')
        if ansible_config and vm_dict:
            if not __apply_ansible_playbooks(
                    ansible_config, os_creds_dict, vm_dict, images_dict,
                    flavors_dict, networks_dict, routers_dict, tmplt_file):
                logger.error("Problem applying ansible playbooks")


def __get_creds_dict(os_conn_config):
    """
    Returns a dict of OSCreds where the key is the creds name.
    For backwards compatibility, credentials not contained in a list (only
    one) will be returned with the key of None
    :param os_conn_config: the credential configuration
    :return: a dict of OSCreds objects
    """
    if 'connection' in os_conn_config:
        return {DEFAULT_CREDS_KEY: __get_os_credentials(os_conn_config)}
    elif 'connections' in os_conn_config:
        out = dict()
        for os_conn_dict in os_conn_config['connections']:
            config = os_conn_dict.get('connection')
            if not config:
                raise Exception('Invalid connection format')

            name = config.get('name')
            if not name:
                raise Exception('Connection config requires a name field')

            out[name] = __get_os_credentials(os_conn_dict)
        return out


def __get_creds(os_creds_dict, os_user_dict, inst_config):
    """
    Returns the appropriate credentials
    :param os_creds_dict: a dictionary of OSCreds objects where the name is the
                          key
    :param os_user_dict: a dictionary of OpenStackUser objects where the name
                         is the key
    :param inst_config:
    :return: an OSCreds instance or None
    """
    os_creds = os_creds_dict.get(DEFAULT_CREDS_KEY)
    if 'os_user' in inst_config:
        os_user_conf = inst_config['os_user']
        if 'name' in os_user_conf:
            user_creator = os_user_dict.get(os_user_conf['name'])
            if user_creator:
                return user_creator.get_os_creds(
                    project_name=os_user_conf.get('project_name'))
    elif 'os_creds_name' in inst_config:
        if 'os_creds_name' in inst_config:
            os_creds = os_creds_dict[inst_config['os_creds_name']]
    return os_creds


def __get_os_credentials(os_conn_config):
    """
    Returns an object containing all of the information required to access
    OpenStack APIs
    :param os_conn_config: The configuration holding the credentials
    :return: an OSCreds instance
    """
    config = os_conn_config.get('connection')
    if not config:
        raise Exception('Invalid connection configuration')

    proxy_settings = None
    http_proxy = config.get('http_proxy')
    if http_proxy:
        tokens = re.split(':', http_proxy)
        ssh_proxy_cmd = config.get('ssh_proxy_cmd')
        proxy_settings = ProxySettings(host=tokens[0], port=tokens[1],
                                       ssh_proxy_cmd=ssh_proxy_cmd)
    else:
        if 'proxy_settings' in config:
            host = config['proxy_settings'].get('host')
            port = config['proxy_settings'].get('port')
            if host and host != 'None' and port and port != 'None':
                proxy_settings = ProxySettings(**config['proxy_settings'])

    if proxy_settings:
        config['proxy_settings'] = proxy_settings
    else:
        if config.get('proxy_settings'):
            del config['proxy_settings']

    return OSCreds(**config)


def __parse_ports_config(config):
    """
    Parses the "ports" configuration
    :param config: The dictionary to parse
    :return: a list of PortConfig objects
    """
    out = list()
    for port_config in config:
        out.append(PortConfig(**port_config.get('port')))
    return out


def __create_instances(os_creds_dict, creator_class, config_class, config,
                       config_key, cleanup=False, os_users_dict=None):
    """
    Returns a dictionary of SNAPS creator objects where the key is the name
    :param os_creds_dict: Dictionary of OSCreds objects where the key is the
                          name
    :param config: The list of configurations for the same type
    :param config_key: The list of configurations for the same type
    :param cleanup: Denotes whether or not this is being called for cleanup
    :return: dictionary
    """
    out = {}

    if config:
        for config_dict in config:
            inst_config = config_dict.get(config_key)
            if inst_config:
                creds = __get_creds(os_creds_dict, os_users_dict, inst_config)
                if creds:
                    creator = creator_class(
                        creds,
                        config_class(**inst_config))

                    if creator:
                        if cleanup:
                            try:
                                creator.initialize()
                            except Unauthorized as e:
                                logger.warn(
                                    'Unable to initialize creator [%s] - %s',
                                    creator, e)
                        else:
                            creator.create()

                        out[inst_config['name']] = creator
                    else:
                        raise Exception('Unable to instantiate creator')

        logger.info('Initialized configured %ss', config_key)

    return out


def __create_vm_instances(os_creds_dict, os_users_dict, instances_config,
                          image_dict, keypairs_dict, cleanup=False):
    """
    Returns a dictionary of OpenStackVmInstance objects where the key is the
    instance name
    :param os_creds_dict: Dictionary of OSCreds objects where the key is the
                          name
    :param os_users_dict: Dictionary of OpenStackUser objects where the key is
                          the username
    :param instances_config: The list of VM instance configurations
    :param image_dict: A dictionary of images that will probably be used to
                       instantiate the VM instance
    :param keypairs_dict: A dictionary of keypairs that will probably be used
                          to instantiate the VM instance
    :param cleanup: Denotes whether or not this is being called for cleanup
    :return: dictionary
    """
    vm_dict = {}

    if instances_config:
        for instance_config in instances_config:
            conf = instance_config.get('instance')
            if conf:
                if image_dict:
                    image_creator = image_dict.get(conf.get('imageName'))
                    if image_creator:
                        instance_settings = VmInstanceConfig(
                            **instance_config['instance'])
                        kp_creator = keypairs_dict.get(
                            conf.get('keypair_name'))

                        try:
                            vm_dict[conf[
                                'name']] = deploy_utils.create_vm_instance(
                                __get_creds(
                                    os_creds_dict, os_users_dict, conf),
                                instance_settings,
                                image_creator.image_settings,
                                keypair_creator=kp_creator,
                                init_only=cleanup)
                        except Unauthorized as e:
                            if not cleanup:
                                logger.warn('Unable to initialize VM - %s', e)
                                raise
                    else:
                        raise Exception('Image creator instance not found.'
                                        ' Cannot instantiate')
                else:
                    if not cleanup:
                        raise Exception('Image dictionary is None. Cannot '
                                        'instantiate')
            else:
                raise Exception('Instance configuration is None. Cannot '
                                'instantiate')
        logger.info('Created configured instances')

    return vm_dict


def __apply_ansible_playbooks(ansible_configs, os_creds_dict, vm_dict,
                              image_dict, flavor_dict, networks_dict,
                              routers_dict, tmplt_file):
    """
    Applies ansible playbooks to running VMs with floating IPs
    :param ansible_configs: a list of Ansible configurations
    :param os_creds_dict: Dictionary of OSCreds objects where the key is the
                          name
    :param vm_dict: the dictionary of newly instantiated VMs where the name is
                    the key
    :param image_dict: the dictionary of newly instantiated images where the
                       name is the key
    :param flavor_dict: the dictionary of newly instantiated flavors where the
                        name is the key
    :param networks_dict: the dictionary of newly instantiated networks where
                          the name is the key
    :param routers_dict: the dictionary of newly instantiated routers where
                          the name is the key
    :param tmplt_file: the path of the SNAPS-OO template file for setting the
                       CWD so playbook location is relative to the deployment
                       file
    :return: t/f - true if successful
    """
    logger.info("Applying Ansible Playbooks")
    if ansible_configs:
        # Set CWD so the deployment file's playbook location can leverage
        # relative paths
        orig_cwd = os.getcwd()
        env_dir = os.path.dirname(tmplt_file)
        os.chdir(env_dir)

        # Apply playbooks
        for ansible_config in ansible_configs:
            # Ensure all hosts are accepting SSH session requests
            for vm_name in ansible_config['hosts']:
                vm_inst = vm_dict.get(vm_name)
                if vm_inst:
                    if not vm_inst.vm_ssh_active(block=True):
                        logger.warning(
                            'Timeout waiting for instance to respond to '
                            'SSH requests')
                        return False

            __apply_ansible_playbook(
                ansible_config, os_creds_dict, vm_dict, image_dict,
                flavor_dict, networks_dict, routers_dict)

        # Return to original directory
        os.chdir(orig_cwd)

    return True


def __apply_ansible_playbook(ansible_config, os_creds_dict, vm_dict,
                             image_dict, flavor_dict, networks_dict,
                             routers_dict):
    """
    Applies an Ansible configuration setting
    :param ansible_config: the configuration settings
    :param os_creds_dict: dict where the key is the name and value is OSCreds
    :param vm_dict: the dictionary of newly instantiated VMs where the name is
                    the key
    :param image_dict: the dictionary of newly instantiated images where the
                       name is the key
    :param flavor_dict: the dictionary of newly instantiated flavors where the
                        name is the key
    :param networks_dict: the dictionary of newly instantiated networks where
                          the name is the key
    :param routers_dict: the dictionary of newly instantiated routers where
                          the name is the key
    """
    if ansible_config:
        (remote_user, floating_ips, private_key_filepath,
         proxy_settings) = __get_connection_info(
            ansible_config, vm_dict)
        if floating_ips:
            for key, vm_creator in vm_dict.items():
                fip = vm_creator.get_floating_ip()
                if fip and fip.ip in floating_ips:
                    if not vm_creator.cloud_init_complete(block=True):
                        raise Exception(
                            'Cannot apply playbooks as cloud-init has not '
                            'completed')

            variables = __get_variables(
                ansible_config.get('variables'), os_creds_dict, vm_dict,
                image_dict, flavor_dict, networks_dict, routers_dict)

            ansible_utils.apply_playbook(
                ansible_config['playbook_location'], floating_ips, remote_user,
                ssh_priv_key_file_path=private_key_filepath,
                variables=variables,
                proxy_setting=proxy_settings)

            if 'post_processing' in ansible_config:
                post_proc_config = ansible_config['post_processing']
                if 'sleep' in post_proc_config:
                    time.sleep(post_proc_config['sleep'])
                if 'reboot' in post_proc_config:
                    for vm_name in post_proc_config['reboot']:
                        if vm_name in vm_dict:
                            logger.info('Rebooting VM - %s', vm_name)
                            vm_dict[vm_name].reboot(RebootType.hard)


def __get_connection_info(ansible_config, vm_dict):
    """
    Returns a tuple of data required for connecting to the running VMs
    (remote_user, [floating_ips], private_key_filepath, proxy_settings)
    :param ansible_config: the configuration settings
    :param vm_dict: the dictionary of VMs where the VM name is the key
    :return: tuple where the first element is the user and the second is a list
             of floating IPs and the third is the
    private key file location and the fourth is an instance of the
    snaps.ProxySettings class
    (note: in order to work, each of the hosts need to have the same sudo_user
    and private key file location values)
    """
    if ansible_config.get('hosts'):
        hosts = ansible_config['hosts']
        if len(hosts) > 0:
            floating_ips = list()
            remote_user = None
            pk_file = None
            proxy_settings = None
            for host in hosts:
                vm = vm_dict.get(host)
                if vm:
                    fip = vm.get_floating_ip()
                    if fip:
                        remote_user = vm.get_image_user()

                        if fip:
                            floating_ips.append(fip.ip)
                        else:
                            raise Exception(
                                'Could not find floating IP for VM - ' +
                                vm.name)

                        pk_file = vm.keypair_settings.private_filepath
                        proxy_settings = vm.get_os_creds().proxy_settings
                else:
                    logger.error('Could not locate VM with name - ' + host)

            return remote_user, floating_ips, pk_file, proxy_settings
    return None


def __get_variables(var_config, os_creds_dict, vm_dict, image_dict,
                    flavor_dict, networks_dict, routers_dict):
    """
    Returns a dictionary of substitution variables to be used for Ansible
    templates
    :param var_config: the variable configuration settings
    :param os_creds_dict: dict where the key is the name and value is OSCreds
    :param vm_dict: the dictionary of newly instantiated VMs where the name is
                    the key
    :param image_dict: the dictionary of newly instantiated images where the
                       name is the key
    :param flavor_dict: the dictionary of newly instantiated flavors where the
                        name is the key
    :param networks_dict: the dictionary of newly instantiated networks where
                          the name is the key
    :param routers_dict: the dictionary of newly instantiated routers where
                          the name is the key
    :return: dictionary or None
    """
    if var_config and vm_dict and len(vm_dict) > 0:
        variables = dict()
        for key, value in var_config.items():
            value = __get_variable_value(
                value, os_creds_dict, vm_dict, image_dict, flavor_dict,
                networks_dict, routers_dict)
            if key and value:
                variables[key] = value
                logger.info(
                    "Set Jinga2 variable with key [%s] the value [%s]",
                    key, value)
            else:
                raise Exception(
                    'Key - [' + str(key) + '] or Value [' + str(value)
                    + '] must not be None')
        return variables
    return None


def __get_variable_value(var_config_values, os_creds_dict, vm_dict, image_dict,
                         flavor_dict, networks_dict, routers_dict):
    """
    Returns the associated variable value for use by Ansible for substitution
    purposes
    :param var_config_values: the configuration dictionary
    :param os_creds_dict: dict where the key is the name and value is OSCreds
    :param vm_dict: the dictionary of newly instantiated VMs where the name is
                    the key
    :param image_dict: the dictionary of newly instantiated images where the
                       name is the key
    :param flavor_dict: the dictionary of newly instantiated flavors where the
                        name is the key
    :param networks_dict: the dictionary of newly instantiated networks where
                          the name is the key
    :param routers_dict: the dictionary of newly instantiated routers where
                          the name is the key
    :return:
    """
    if var_config_values['type'] == 'string':
        return __get_string_variable_value(var_config_values)
    if var_config_values['type'] == 'vm-attr':
        return __get_vm_attr_variable_value(var_config_values, vm_dict)
    if var_config_values['type'] == 'os_creds':
        return __get_os_creds_variable_value(var_config_values, os_creds_dict)
    if var_config_values['type'] == 'os_creds_dict':
        return str(__get_os_creds_dict(var_config_values, os_creds_dict))
    if var_config_values['type'] == 'network':
        return __get_network_variable_value(var_config_values, networks_dict)
    if var_config_values['type'] == 'router':
        return __get_router_variable_value(var_config_values, routers_dict,
                                           os_creds_dict)
    if var_config_values['type'] == 'port':
        return __get_vm_port_variable_value(var_config_values, vm_dict)
    if var_config_values['type'] == 'floating_ip':
        return __get_vm_fip_variable_value(var_config_values, vm_dict)
    if var_config_values['type'] == 'image':
        return __get_image_variable_value(var_config_values, image_dict)
    if var_config_values['type'] == 'flavor':
        return __get_flavor_variable_value(var_config_values, flavor_dict)
    if var_config_values['type'] == 'vm-yaml':
        return __create_yaml(var_config_values, vm_dict)
    return None


def __get_string_variable_value(var_config_values):
    """
    Returns the associated string value
    :param var_config_values: the configuration dictionary
    :return: the value contained in the dictionary with the key 'value'
    """
    return var_config_values['value']


def __get_vm_attr_variable_value(var_config_values, vm_dict):
    """
    Returns the associated value contained on a VM instance
    :param var_config_values: the configuration dictionary
    :param vm_dict: the dictionary containing all VMs where the key is the VM's
                    name
    :return: the value
    """
    vm = vm_dict.get(var_config_values['vm_name'])
    if vm:
        if var_config_values['value'] == 'floating_ip':
            return vm.get_floating_ip().ip
        if var_config_values['value'] == 'image_user':
            return vm.get_image_user()


def __get_os_creds_variable_value(var_config_values, os_creds_dict):
    """
    Returns the associated OS credentials value
    :param var_config_values: the configuration dictionary
    :param os_creds_dict: dict of OpenStack credentials where the key is the
                          name
    :return: the value
    """
    if 'creds_name' in var_config_values:
        os_creds = os_creds_dict.get[var_config_values['creds_name']]
    else:
        os_creds = os_creds_dict.get('admin-creds')

    if os_creds:
        if var_config_values['value'] == 'username':
            logger.info("Returning OS username")
            return os_creds.username
        elif var_config_values['value'] == 'password':
            logger.info("Returning OS password")
            return os_creds.password
        elif var_config_values['value'] == 'auth_url':
            logger.info("Returning OS auth_url")
            return os_creds.auth_url
        elif var_config_values['value'] == 'project_name':
            logger.info("Returning OS project_name")
            return os_creds.project_name


def __get_os_creds_dict(var_config_values, os_creds_dict):
    """
    Returns the associated OS credentials as a dict
    :param var_config_values: the configuration dictionary
    :param os_creds_dict: dict of creds where the key is the username
    :return: the value dict
    """
    if 'creds_name' in var_config_values:
        os_creds = os_creds_dict.get[var_config_values['creds_name']]
    else:
        os_creds = os_creds_dict.get('admin-creds')
    if os_creds:
        return os_creds.to_dict()


def __get_network_variable_value(var_config_values, networks_dict):
    """
    Returns the associated network value
    :param var_config_values: the configuration dictionary
    :param networks_dict: the dictionary containing all networks where the key
                          is the network name
    :return: the value
    """
    net_name = var_config_values.get('network_name')

    if net_name and networks_dict.get(net_name):
        network_creator = networks_dict[net_name]

        if 'subnet_name' in var_config_values:
            subnet_name = var_config_values.get('subnet_name')
            if subnet_name:
                for subnet in network_creator.get_network().subnets:
                    if subnet_name == subnet.name:
                        if 'value' in var_config_values:
                            if 'gateway_ip' == var_config_values['value']:
                                return subnet.gateway_ip
                            if 'ip_range' == var_config_values['value']:
                                return subnet.start + ' ' + subnet.end
                            if 'ip_range_start' == var_config_values['value']:
                                return subnet.start
                            if 'ip_range_end' == var_config_values['value']:
                                return subnet.end
                            if 'cidr' == var_config_values['value']:
                                return subnet.cidr
                            if 'cidr_ip' == var_config_values['value']:
                                cidr_split = subnet.cidr.split('/')
                                return cidr_split[0]
                            if 'netmask' == var_config_values['value']:
                                cidr_split = subnet.cidr.split('/')
                                cidr_bits = 32 - int(cidr_split[1])
                                netmask = socket.inet_ntoa(
                                    struct.pack(
                                        '!I', (1 << 32) - (1 << cidr_bits)))
                                return netmask
                            if 'broadcast_ip' == var_config_values['value']:
                                end_split = subnet.end.split('.')
                                broadcast_ip = (
                                    end_split[0] + '.' + end_split[1] + '.'
                                    + end_split[2] + '.255')
                                return broadcast_ip


def __get_router_variable_value(var_config_values, routers_dict,
                                os_creds_dict):
    """
    Returns the associated network value
    :param var_config_values: the configuration dictionary
    :param routers_dict: the dictionary containing all networks where the key
                          is the network name
    :param os_creds_dict: dict of OpenStack credentials where the key is the
                          name
    :return: the value
    """
    if 'creds_name' in var_config_values:
        os_creds = os_creds_dict.get[var_config_values['creds_name']]
    else:
        os_creds = os_creds_dict.get('admin-creds')

    router_name = var_config_values.get('router_name')
    router_creator = routers_dict[router_name]

    if router_creator:
        if 'external_fixed_ip' == var_config_values.get('attr'):
            session = keystone_utils.keystone_session(os_creds)
            neutron = neutron_utils.neutron_client(os_creds, session)
            try:
                ext_nets = neutron_utils.get_external_networks(neutron)

                subnet_name = var_config_values.get('subnet_name')

                for ext_net in ext_nets:
                    for subnet in ext_net.subnets:
                        if subnet_name == subnet.name:
                            router = router_creator.get_router()
                            for fixed_ips in router.external_fixed_ips:
                                if subnet.id == fixed_ips['subnet_id']:
                                    return fixed_ips['ip_address']
            finally:
                keystone_utils.close_session(session)


def __get_vm_port_variable_value(var_config_values, vm_dict):
    """
    Returns the associated OS credentials value
    :param var_config_values: the configuration dictionary
    :param vm_dict: the dictionary containing all VMs where the key is the VM's
                    name
    :return: the value
    """
    port_name = var_config_values.get('port_name')
    vm_name = var_config_values.get('vm_name')

    if port_name and vm_name:
        vm = vm_dict.get(vm_name)
        if vm:
            for vm_port in vm.get_vm_inst().ports:
                if vm_port.name == port_name:
                    port_value_id = var_config_values.get('port_value')
                    if port_value_id:
                        if port_value_id == 'mac_address':
                            return vm_port.mac_address
                        if port_value_id == 'ip_address':
                            return vm_port.ips[0]['ip_address']


def __get_vm_fip_variable_value(var_config_values, vm_dict):
    """
    Returns the floating IP value if found
    :param var_config_values: the configuration dictionary
    :param vm_dict: the dictionary containing all VMs where the key is the VM's
                    name
    :return: the floating IP string value or None
    """
    fip_name = var_config_values.get('fip_name')
    vm_name = var_config_values.get('vm_name')

    if vm_name:
        vm = vm_dict.get(vm_name)
        if vm:
            fip = vm.get_floating_ip(fip_name)
            if fip:
                return fip.ip


def __get_image_variable_value(var_config_values, image_dict):
    """
    Returns the associated image value
    :param var_config_values: the configuration dictionary
    :param image_dict: the dictionary containing all images where the key is
                       the name
    :return: the value
    """
    if image_dict:
        if var_config_values.get('image_name'):
            image_creator = image_dict.get(var_config_values['image_name'])
            if image_creator:
                if (var_config_values.get('value')
                        and var_config_values['value'] == 'id'):
                    return image_creator.get_image().id
                if (var_config_values.get('value')
                        and var_config_values['value'] == 'user'):
                    return image_creator.image_settings.image_user


def __get_flavor_variable_value(var_config_values, flavor_dict):
    """
    Returns the associated flavor value
    :param var_config_values: the configuration dictionary
    :param flavor_dict: the dictionary containing all flavor creators where the
                        key is the name
    :return: the value or None
    """
    if flavor_dict:
        if var_config_values.get('flavor_name'):
            flavor_creator = flavor_dict.get(var_config_values['flavor_name'])
            if flavor_creator:
                if (var_config_values.get('value')
                        and var_config_values['value'] == 'id'):
                    return flavor_creator.get_flavor().id


def __create_yaml(var_config_values, vm_dict):
    """
    Creates a yaml file containing an OpenStack pod's credentials with a list
    of server IDs that can be used for obtaining SNAPS-OO instances for
    manipulation such as rebooting
    :param var_config_values: the configuration dictionary
    :param vm_dict: the dictionary containing all vm creators where the
                    key is the name
    :return: the name of the generated file
    """
    out_dict = dict()
    out_dict['vms'] = list()
    req_vm_names = var_config_values.get('vms')

    for name, vm_creator in vm_dict.items():
        vm_inst = vm_creator.get_vm_inst()
        if vm_inst and vm_inst.name in req_vm_names:
            out_dict['vms'].append({
                'name': str(vm_inst.name),
                'id': str(vm_inst.id),
                'os_creds': vm_creator.get_os_creds().to_dict()
            })

    out_file = file_utils.persist_dict_to_yaml(
        out_dict, var_config_values.get('file_name'))

    if out_file:
        return out_file.name


def __cleanup(creators, clean_image=False):
    """
    Cleans up environment
    :param creators: the list of creators by type
    :param clean_image: when true
    :return:
    """
    for creator_dict in reversed(creators):
        for key, creator in creator_dict.items():
            if ((isinstance(creator, OpenStackImage) and clean_image)
                    or not isinstance(creator, OpenStackImage)):
                creator.clean()