# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2012 IBM Corp.
#
#    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.

# See: http://wiki.openstack.org/Nova/CoverageExtension for more information
# and usage explanation for this API extension

import os
import re
import socket
import sys
import telnetlib
import tempfile

from oslo.config import cfg
from webob import exc

from nova.api.openstack import extensions
from nova import baserpc
from nova import db
from nova.openstack.common.gettextutils import _
from nova.openstack.common import log as logging
from nova.openstack.common.rpc import common as rpc_common


LOG = logging.getLogger(__name__)
authorize = extensions.extension_authorizer('compute', 'coverage_ext')
CONF = cfg.CONF


class CoverageController(object):
    """The Coverage report API controller for the OpenStack API."""
    def __init__(self):
        self.data_path = None
        self.services = []
        self.combine = False
        self._cover_inst = None
        self.host = CONF.host
        super(CoverageController, self).__init__()

    @property
    def coverInst(self):
        if not self._cover_inst:
            try:
                import coverage
                if self.data_path is None:
                    self.data_path = tempfile.mkdtemp(prefix='nova-coverage_')
                data_out = os.path.join(self.data_path, '.nova-coverage.api')
                self._cover_inst = coverage.coverage(data_file=data_out)
            except ImportError:
                pass
        return self._cover_inst

    def _find_services(self, req):
        """Returns a list of services."""
        context = req.environ['nova.context']
        services = db.service_get_all(context)
        hosts = []
        for serv in services:
            hosts.append({"service": serv["topic"], "host": serv["host"]})
        return hosts

    def _find_ports(self, req, hosts):
        """Return a list of backdoor ports for all services in the list."""
        context = req.environ['nova.context']
        ports = []
        #TODO(mtreinish): Figure out how to bind the backdoor socket to 0.0.0.0
        # Currently this will only work if the host is resolved as loopback on
        # the same host as api-server
        for host in hosts:
            base = baserpc.BaseAPI(host['service'])
            _host = host
            try:
                _host['port'] = base.get_backdoor_port(context, host['host'])
            except rpc_common.UnsupportedRpcVersion:
                _host['port'] = None

            #NOTE(mtreinish): if the port is None then it wasn't set in
            # the configuration file for this service. However, that
            # doesn't necessarily mean that we don't have backdoor ports
            # for all the services. So, skip the telnet connection for
            # this service.
            if _host['port']:
                ports.append(_host)
            else:
                LOG.warning(_("Can't connect to service: %s, no port"
                              "specified\n"), host['service'])
        return ports

    def _start_coverage_telnet(self, tn, service):
        data_file = os.path.join(self.data_path,
                                '.nova-coverage.%s' % str(service))
        tn.write('import sys\n')
        tn.write('from coverage import coverage\n')
        tn.write("coverInst = coverage(data_file='%s') "
                 "if 'coverInst' not in locals() "
                 "else coverInst\n" % data_file)
        tn.write('coverInst.skipModules = sys.modules.keys()\n')
        tn.write("coverInst.start()\n")
        tn.write("print 'finished'\n")
        tn.expect([re.compile('finished')])

    def _start_coverage(self, req, body):
        '''Begin recording coverage information.'''
        LOG.debug(_("Coverage begin"))
        body = body['start']
        self.combine = False
        if 'combine' in body.keys():
            self.combine = bool(body['combine'])
        self.coverInst.skipModules = sys.modules.keys()
        self.coverInst.start()
        hosts = self._find_services(req)
        ports = self._find_ports(req, hosts)
        self.services = []
        for service in ports:
            try:
                service['telnet'] = telnetlib.Telnet(service['host'],
                                                     service['port'])
            # NOTE(mtreinish): Fallback to try connecting to lo if
            # ECONNREFUSED is raised. If using the hostname that is returned
            # for the service from the service_get_all() DB query raises
            # ECONNREFUSED it most likely means that the hostname in the DB
            # doesn't resolve to 127.0.0.1. Currently backdoors only open on
            # loopback so this is for covering the common single host use case
            except socket.error as e:
                exc_info = sys.exc_info()
                if 'ECONNREFUSED' in e and service['host'] == self.host:
                        service['telnet'] = telnetlib.Telnet('127.0.0.1',
                                                             service['port'])
                else:
                    raise exc_info[0], exc_info[1], exc_info[2]
            self.services.append(service)
            self._start_coverage_telnet(service['telnet'], service['service'])

    def _stop_coverage_telnet(self, tn):
        tn.write("coverInst.stop()\n")
        tn.write("coverInst.save()\n")
        tn.write("print 'finished'\n")
        tn.expect([re.compile('finished')])

    def _check_coverage(self):
        try:
            self.coverInst.stop()
            self.coverInst.save()
        except AssertionError:
            return True
        return False

    def _stop_coverage(self, req):
        for service in self.services:
            self._stop_coverage_telnet(service['telnet'])
        if self._check_coverage():
            msg = _("Coverage not running")
            raise exc.HTTPNotFound(explanation=msg)
        return {'path': self.data_path}

    def _report_coverage_telnet(self, tn, path, xml=False):
        if xml:
            execute = str("coverInst.xml_report(outfile='%s')\n" % path)
            tn.write(execute)
            tn.write("print 'finished'\n")
            tn.expect([re.compile('finished')])
        else:
            execute = str("output = open('%s', 'w')\n" % path)
            tn.write(execute)
            tn.write("coverInst.report(file=output)\n")
            tn.write("output.close()\n")
            tn.write("print 'finished'\n")
            tn.expect([re.compile('finished')])
        tn.close()

    def _report_coverage(self, req, body):
        self._stop_coverage(req)
        xml = False
        html = False
        path = None

        body = body['report']
        if 'file' in body.keys():
            path = body['file']
            if path != os.path.basename(path):
                msg = _("Invalid path")
                raise exc.HTTPBadRequest(explanation=msg)
            path = os.path.join(self.data_path, path)
        else:
            msg = _("No path given for report file")
            raise exc.HTTPBadRequest(explanation=msg)

        if 'xml' in body.keys():
            xml = body['xml']
        elif 'html' in body.keys():
            if not self.combine:
                msg = _("You can't use html reports without combining")
                raise exc.HTTPBadRequest(explanation=msg)
            html = body['html']

        if self.combine:
            data_out = os.path.join(self.data_path, '.nova-coverage')
            import coverage
            coverInst = coverage.coverage(data_file=data_out)
            coverInst.combine()
            if xml:
                coverInst.xml_report(outfile=path)
            elif html:
                if os.path.isdir(path):
                    msg = _("Directory conflict: %s already exists") % path
                    raise exc.HTTPBadRequest(explanation=msg)
                coverInst.html_report(directory=path)
            else:
                output = open(path, 'w')
                coverInst.report(file=output)
                output.close()
            for service in self.services:
                service['telnet'].close()
        else:
            if xml:
                apipath = path + '.api'
                self.coverInst.xml_report(outfile=apipath)
                for service in self.services:
                    self._report_coverage_telnet(service['telnet'],
                                              path + '.%s'
                                              % service['service'],
                                              xml=True)
            else:
                output = open(path + '.api', 'w')
                self.coverInst.report(file=output)
                for service in self.services:
                    self._report_coverage_telnet(service['telnet'],
                                            path + '.%s' % service['service'])
                output.close()
        return {'path': path}

    def _reset_coverage_telnet(self, tn):
        tn.write("coverInst.erase()\n")
        tn.write("print 'finished'\n")
        tn.expect([re.compile('finished')])

    def _reset_coverage(self, req):
        # Reopen telnet connections if they are closed.
        for service in self.services:
            if not service['telnet'].get_socket():
                service['telnet'].open(service['host'], service['port'])

        # Stop coverage if it is started.
        try:
            self._stop_coverage(req)
        except exc.HTTPNotFound:
            pass

        for service in self.services:
            self._reset_coverage_telnet(service['telnet'])
            service['telnet'].close()
        self.coverInst.erase()

    def action(self, req, body):
        _actions = {
                'start': self._start_coverage,
                'stop': self._stop_coverage,
                'report': self._report_coverage,
                'reset': self._reset_coverage,
        }
        authorize(req.environ['nova.context'])
        if not self.coverInst:
            msg = _("Python coverage module is not installed.")
            raise exc.HTTPServiceUnavailable(explanation=msg)
        for action, data in body.iteritems():
            if action == 'stop' or action == 'reset':
                return _actions[action](req)
            elif action == 'report' or action == 'start':
                return _actions[action](req, body)
            else:
                msg = _("Coverage doesn't have %s action") % action
                raise exc.HTTPBadRequest(explanation=msg)
        raise exc.HTTPBadRequest(explanation=_("Invalid request body"))


class Coverage_ext(extensions.ExtensionDescriptor):
    """Enable Nova Coverage."""

    name = "Coverage"
    alias = "os-coverage"
    namespace = ("http://docs.openstack.org/compute/ext/"
                  "coverage/api/v2")
    updated = "2012-10-15T00:00:00+00:00"

    def get_resources(self):
        resources = []
        res = extensions.ResourceExtension('os-coverage',
                                        controller=CoverageController(),
                                        collection_actions={"action": "POST"})
        resources.append(res)
        return resources
