tester.py

# -*- coding: utf-8 -*-
from __future__ import absolute_import, print_function

import json
import logging.handlers
import os
import sys

import ansible
import firebase_admin
import hashids
from ansible.cli import CLI
from ansible.inventory.host import Host
from ansible.inventory.manager import InventoryManager
from ansible.parsing.dataloader import DataLoader
from ansible.template import Templar
from ansible.vars.manager import VariableManager
from ansible.module_utils.facts import ansible_collector, default_collectors
from ansible.module_utils.facts.collector import CollectorNotFoundError, CycleFoundInFactDeps, UnresolvedFactDep
from ansible.module_utils.facts.namespace import PrefixFactNamespace
from firebase_admin import credentials, db
from flask import Flask, abort, render_template, request, send_from_directory
from importlib.metadata import version

import config

# import pydevd_pycharm



def is_snapshots_enabled():
    return config.FIREBASE_URL is not None and config.FIREBASE_CREDENTIALS is not None


base_dir = '.'
if hasattr(sys, '_MEIPASS'):
    base_dir = os.path.join(sys._MEIPASS)

server = Flask(__name__,
               static_folder=os.path.join(base_dir, 'static'),
               template_folder=os.path.join(base_dir, 'templates'))

if is_snapshots_enabled():
    hasher = hashids.Hashids(config.FIREBASE_URL, min_length=6)
    cred = credentials.Certificate(config.FIREBASE_CREDENTIALS)
    firebase_admin.initialize_app(cred, {
        'databaseURL': config.FIREBASE_URL
    })
    counter_db = db.reference('counter')
    snapshots_db = db.reference('snapshots')


@server.route("/")
@server.route("/<code>")
def home(code=None):
    enable_snapshots = is_snapshots_enabled()
    values_type = "yaml"
    values = ""
    template = ""
    render_type_name = "Plain text"
    render_type_value = "ace/mode/plain_text"
    render = ""
    if code is not None:
        if not enable_snapshots:
            abort(404)
        # noinspection PyBroadException
        try:
            snapshots = snapshots_db.order_by_key().equal_to(code).limit_to_first(1).get()
            _, snapshot_value = next(iter(snapshots.items()))
            values_type = escape_value(snapshot_value['values_type'])
            values = escape_value(snapshot_value['values'])
            template = escape_value(snapshot_value['template'])
            if 'render_type_name' in snapshot_value:
                render_type_name = escape_value(snapshot_value['render_type_name'])
            if 'render_type_value' in snapshot_value:
                render_type_value = escape_value(snapshot_value['render_type_value'])
            render = escape_value(snapshot_value['render'])
        except Exception as e:
            server.logger.exception('Failed to load snapshot: %s', e, )
            abort(500)

    return render_template('index.html', enable_snapshots=enable_snapshots, values_type=values_type, values=values,
                           template=template, render_type_name=render_type_name, render_type_value=render_type_value,
                           render=render, ansible_version=version('ansible'), ansible_core_version=ansible.__version__)


@server.route('/favicon.ico')
def favicon():
    return send_from_directory(os.path.join(server.root_path, 'static', 'images'),
                               'favicon.png', mimetype='image/png')


@server.route("/snapshot", methods=['POST'])
def snapshot():
    if not is_snapshots_enabled():
        abort(404)

    values_type = get_values_type()
    values = get_values()
    template = get_template()
    render_type_name = get_render_type_name()
    render_type_value = get_render_type_value()
    render = get_render()
    data = {
        "values_type": values_type,
        "values": values,
        "template": template,
        "render_type_name": render_type_name,
        "render_type_value": render_type_value,
        "render": render,
        "timestamp": {".sv": "timestamp"}
    }
    # noinspection PyBroadException
    try:
        new_id = counter_db.transaction(increment_counter)
        code = hasher.encode(new_id)
        snapshots_db.child(code).set(data)
        return "%s%s" % (request.url_root, code)
    except Exception as e:
        server.logger.exception('Failed to save snapshot: %s', e, )
        abort(500)


def increment_counter(current_value):
    return current_value + 1 if current_value else 1


@server.route('/test', methods=['GET', 'POST'])
def test():
    # pydevd_pycharm.settrace('localhost', port=54334, stdoutToServer=True, stderrToServer=True)

    try:
        loader = DataLoader()
        ds = loader.load(get_values())

        inventory = InventoryManager(loader=loader)
        if ds is not None:
            for key, value in ds.items():
                inventory.groups['all'].set_variable(key, value)

        all_collector_classes = default_collectors.collectors

        namespace = PrefixFactNamespace(namespace_name='ansible',
                                        prefix='ansible_')

        minimal_gather_subset = frozenset(['apparmor', 'caps', 'cmdline', 'date_time',
                                           'distribution', 'dns', 'env', 'fips', 'local',
                                           'lsb', 'pkg_mgr', 'platform', 'python', 'selinux',
                                           'service_mgr', 'ssh_pub_keys', 'user'])

        try:
            fact_collector = ansible_collector.get_ansible_collector(all_collector_classes=all_collector_classes,
                                                                     namespace=namespace,
                                                                     filter_spec=[],
                                                                     gather_subset=["!all"],
                                                                     gather_timeout=10,
                                                                     minimal_gather_subset=minimal_gather_subset)

            facts_dict = fact_collector.collect()

            host = Host(name='all')

            variable_manager = VariableManager(loader=loader, inventory=inventory, version_info=CLI.version_info(gitinfo=False))
            variable_manager.set_host_facts(host.name, facts_dict.copy())

            templar = Templar(loader=loader)
            templar.available_variables = variable_manager.get_vars(host=host)
            try:
                rendered = templar.template(get_template(), convert_data=False, cache=False)
            except Exception as e:
                rendered = "Template rendering failed: {0}".format(e)

        except (TypeError, CollectorNotFoundError, CycleFoundInFactDeps, UnresolvedFactDep) as e:
            rendered = "Fact gathering failed: {0}".format(e)

    except Exception as e:
        rendered = "Template syntax error: {0}".format(e)

    result = {
        "result": str(rendered)
    }

    return json.dumps(result)


def get_values_type():
    if request.form['values_type'] == "json":
        return "json"
    elif request.form['values_type'] == "yaml":
        return "yaml"
    else:
        return "Unsupported value type: {0}".format(request.form['values_type'])


def get_values():
    return request.form['values']


def get_template():
    return request.form['template']


def get_render():
    return request.form['render']


def get_render_type_name():
    return request.form['render_type_name']


def get_render_type_value():
    return request.form['render_type_value']


def escape_value(value):
    return str(value).encode('unicode-escape').decode("utf-8").replace('"', '\\"')


if __name__ == "__main__":
    server.logger.setLevel(logging.__getattribute__(config.LOGGING_LEVEL))
    file_handler = logging.handlers.RotatingFileHandler(filename=config.LOGGING_LOCATION, maxBytes=10*1024*1024,
                                                        backupCount=5)
    file_handler.setFormatter(logging.Formatter(config.LOGGING_FORMAT))
    file_handler.setLevel(logging.__getattribute__(config.LOGGING_LEVEL))
    server.logger.addHandler(file_handler)

    server.run(
        host=config.HOST,
        port=config.PORT,
        debug=config.DEBUG,
    )