path: root/yardstick/benchmark/contexts/heat.py

##############################################################################
# Copyright (c) 2015 Ericsson AB and others.
#
# 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
##############################################################################

from __future__ import absolute_import
from __future__ import print_function

import collections
import logging
import os
import sys
import uuid

import paramiko
import pkg_resources

from yardstick.benchmark.contexts.base import Context
from yardstick.benchmark.contexts.model import Network
from yardstick.benchmark.contexts.model import PlacementGroup, ServerGroup
from yardstick.benchmark.contexts.model import Server
from yardstick.benchmark.contexts.model import update_scheduler_hints
from yardstick.orchestrator.heat import HeatTemplate, get_short_key_uuid
from yardstick.common.constants import YARDSTICK_ROOT_PATH

LOG = logging.getLogger(__name__)


class HeatContext(Context):
    """Class that represents a context in the logical model"""

    __context_type__ = "Heat"

    def __init__(self):
        self.name = None
        self.stack = None
        self.networks = []
        self.servers = []
        self.placement_groups = []
        self.server_groups = []
        self.keypair_name = None
        self.secgroup_name = None
        self._server_map = {}
        self._image = None
        self._flavor = None
        self._user = None
        self.template_file = None
        self.heat_parameters = None
        # generate an uuid to identify yardstick_key
        # the first 8 digits of the uuid will be used
        self.key_uuid = uuid.uuid4()
        self.key_filename = ''.join(
            [YARDSTICK_ROOT_PATH, 'yardstick/resources/files/yardstick_key-',
             get_short_key_uuid(self.key_uuid)])
        super(HeatContext, self).__init__()

    def assign_external_network(self, networks):
        sorted_networks = sorted(networks.items())
        external_network = os.environ.get("EXTERNAL_NETWORK", "net04_ext")
        have_external_network = [(name, net)
                                 for name, net in sorted_networks if
                                 net.get("external_network")]
        # no external net defined, assign it to first network usig os.environ
        if sorted_networks and not have_external_network:
            sorted_networks[0][1]["external_network"] = external_network

    def init(self, attrs):     # pragma: no cover
        """initializes itself from the supplied arguments"""
        self.name = attrs["name"]

        self._user = attrs.get("user")

        self.template_file = attrs.get("heat_template")
        if self.template_file:
            self.heat_parameters = attrs.get("heat_parameters")
            return

        self.keypair_name = self.name + "-key"
        self.secgroup_name = self.name + "-secgroup"

        self._image = attrs.get("image")

        self._flavor = attrs.get("flavor")

        self.placement_groups = [PlacementGroup(name, self, pgattrs["policy"])
                                 for name, pgattrs in attrs.get(
                                 "placement_groups", {}).items()]

        self.server_groups = [ServerGroup(name, self, sgattrs["policy"])
                              for name, sgattrs in attrs.get(
                              "server_groups", {}).items()]

        self.assign_external_network(attrs["networks"])

        self.networks = [Network(name, self, netattrs) for name, netattrs in
                         sorted(attrs["networks"].items())]

        for name, serverattrs in attrs["servers"].items():
            server = Server(name, self, serverattrs)
            self.servers.append(server)
            self._server_map[server.dn] = server

        rsa_key = paramiko.RSAKey.generate(bits=2048, progress_func=None)
        rsa_key.write_private_key_file(self.key_filename)
        print("Writing %s ..." % self.key_filename)
        with open(self.key_filename + ".pub", "w") as pubkey_file:
            pubkey_file.write(
                "%s %s\n" % (rsa_key.get_name(), rsa_key.get_base64()))
        del rsa_key

    @property
    def image(self):
        """returns application's default image name"""
        return self._image

    @property
    def flavor(self):
        """returns application's default flavor name"""
        return self._flavor

    @property
    def user(self):
        """return login user name corresponding to image"""
        return self._user

    def _add_resources_to_template(self, template):
        """add to the template the resources represented by this context"""
        template.add_keypair(self.keypair_name, self.key_uuid)
        template.add_security_group(self.secgroup_name)

        for network in self.networks:
            template.add_network(network.stack_name,
                                 network.physical_network,
                                 network.provider)
            template.add_subnet(network.subnet_stack_name,
                                network.stack_name,
                                network.subnet_cidr)

            if network.router:
                template.add_router(network.router.stack_name,
                                    network.router.external_gateway_info,
                                    network.subnet_stack_name)
                template.add_router_interface(network.router.stack_if_name,
                                              network.router.stack_name,
                                              network.subnet_stack_name)

        # create a list of servers sorted by increasing no of placement groups
        list_of_servers = sorted(self.servers,
                                 key=lambda s: len(s.placement_groups))

        #
        # add servers with scheduler hints derived from placement groups
        #

        # create list of servers with availability policy
        availability_servers = []
        for server in list_of_servers:
            for pg in server.placement_groups:
                if pg.policy == "availability":
                    availability_servers.append(server)
                    break

        # add servers with availability policy
        added_servers = []
        for server in availability_servers:
            scheduler_hints = {}
            for pg in server.placement_groups:
                update_scheduler_hints(scheduler_hints, added_servers, pg)
            # workround for openstack nova bug, check JIRA: YARDSTICK-200
            # for details
            if len(availability_servers) == 2:
                if not scheduler_hints["different_host"]:
                    scheduler_hints.pop("different_host", None)
                    server.add_to_template(template,
                                           self.networks,
                                           scheduler_hints)
                else:
                    scheduler_hints["different_host"] = \
                        scheduler_hints["different_host"][0]
                    server.add_to_template(template,
                                           self.networks,
                                           scheduler_hints)
            else:
                server.add_to_template(template,
                                       self.networks,
                                       scheduler_hints)
            added_servers.append(server.stack_name)

        # create list of servers with affinity policy
        affinity_servers = []
        for server in list_of_servers:
            for pg in server.placement_groups:
                if pg.policy == "affinity":
                    affinity_servers.append(server)
                    break

        # add servers with affinity policy
        for server in affinity_servers:
            if server.stack_name in added_servers:
                continue
            scheduler_hints = {}
            for pg in server.placement_groups:
                update_scheduler_hints(scheduler_hints, added_servers, pg)
            server.add_to_template(template, self.networks, scheduler_hints)
            added_servers.append(server.stack_name)

        # add server group
        for sg in self.server_groups:
            template.add_server_group(sg.name, sg.policy)

        # add remaining servers with no placement group configured
        for server in list_of_servers:
            # TODO placement_group and server_group should combine
            if not server.placement_groups:
                scheduler_hints = {}
                # affinity/anti-aff server group
                sg = server.server_group
                if sg:
                    scheduler_hints["group"] = {'get_resource': sg.name}
                server.add_to_template(template,
                                       self.networks, scheduler_hints)

    def deploy(self):
        """deploys template into a stack using cloud"""
        print("Deploying context '%s'" % self.name)

        heat_template = HeatTemplate(self.name, self.template_file,
                                     self.heat_parameters)

        if self.template_file is None:
            self._add_resources_to_template(heat_template)

        try:
            self.stack = heat_template.create()
        except KeyboardInterrupt:
            sys.exit("\nStack create interrupted")
        except RuntimeError as err:
            sys.exit("error: failed to deploy stack: '%s'" % err.args)
        except Exception as err:
            sys.exit("error: failed to deploy stack: '%s'" % err)

        # copy some vital stack output into server objects
        for server in self.servers:
            if server.ports:
                # TODO(hafe) can only handle one internal network for now
                port = next(iter(server.ports.values()))
                server.private_ip = self.stack.outputs[port["stack_name"]]

            if server.floating_ip:
                server.public_ip = \
                    self.stack.outputs[server.floating_ip["stack_name"]]

        print("Context '%s' deployed" % self.name)

    def undeploy(self):
        """undeploys stack from cloud"""
        if self.stack:
            print("Undeploying context '%s'" % self.name)
            self.stack.delete()
            self.stack = None
            print("Context '%s' undeployed" % self.name)

        if os.path.exists(self.key_filename):
            try:
                os.remove(self.key_filename)
                os.remove(self.key_filename + ".pub")
            except OSError:
                LOG.exception("Key filename %s", self.key_filename)

        super(HeatContext, self).undeploy()

    def _get_server(self, attr_name):
        """lookup server info by name from context
        attr_name: either a name for a server created by yardstick or a dict
        with attribute name mapping when using external heat templates
        """
        key_filename = pkg_resources.resource_filename(
            'yardstick.resources',
            'files/yardstick_key-' + get_short_key_uuid(self.key_uuid))

        if isinstance(attr_name, collections.Mapping):
            cname = attr_name["name"].split(".")[1]
            if cname != self.name:
                return None

            public_ip = None
            private_ip = None
            if "public_ip_attr" in attr_name:
                public_ip = self.stack.outputs[attr_name["public_ip_attr"]]
            if "private_ip_attr" in attr_name:
                private_ip = self.stack.outputs[
                    attr_name["private_ip_attr"]]

            # Create a dummy server instance for holding the *_ip attributes
            server = Server(attr_name["name"].split(".")[0], self, {})
            server.public_ip = public_ip
            server.private_ip = private_ip
        else:
            if attr_name not in self._server_map:
                return None
            server = self._server_map[attr_name]

        if server is None:
            return None

        result = {
            "user": server.context.user,
            "key_filename": key_filename,
            "private_ip": server.private_ip
        }
        # Target server may only have private_ip
        if server.public_ip:
            result["ip"] = server.public_ip

        return result