UTeslaCLI

#!/usr/bin/env python3

import os
import asyncio
import logging
import pathlib
import gettext
import tornado.ioloop

from cli_utils import config
from utils.General import parse_config
from utils.extra import init_db
from utils.extra import isinstance_multiple
from utils.extra import init_log
from utils.extra import execute_possible_coroutine
from utils.extra import create_translation

from config import defaults

ioloop = tornado.ioloop.IOLoop().current()

# La configuración
settings = parse_config.parse()
server_conf = settings["Server"]
database = server_conf.get("mysql_db")

# Por si acaso un plugin necesita ser ejecutado hasta que se dicte que no (usado en ioloop, por ejemplo)
is_persist = False

__VERSION__ = "2.0.0"

_ = create_translation.create("UTeslaCLI")

gettext.gettext = create_translation.create("argparse")
    
import argparse

# Iniciamos la configuración para logging
init_log.init(settings["Logging"])

def print_help(parser, args):
    if (args is None) or (hasattr(args, "help")):
        parser.print_help()
        parser.exit()

async def main():
    global is_persist

    # Usado para verificar si hay o no plugins
    plugin_exists = False

    parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
    parser.add_argument(
        "-h", "--help",
        help=_("Imprimir este mensaje y salir"),
        action="store_true"

    )
    parser.add_argument(
        "-s", "--sql-file",
        help=_("El archivo SQL inicial. Advertencia: No modificar si no sabe lo que hace"),
        default=defaults.sqlfile

    )
    parser.add_argument(
        "--version",
        action="store_const",
        const=__VERSION__,
        help=_("muestra la versión del programa y sale")

    )
    parser.add_argument(
        "--no-add-path",
        help=_("No agregar la ruta de trabajo del plugin si existe"),
        action="store_false"

    )
    parser.add_argument(
        "--path",
        help=_("Rutas de trabajo arbitrarias"),
        action="append",
        default=[]

    )
    parser.add_argument(
        "--no-restore",
        help=_("No restaurar el valor de la variable 'PATH', por lo que seguirán "
               "las rutas de trabajo de los plugins. ADVERTENCIA: puede "
               "provocar comportamientos inesperados"),
        action="store_false"

    )

    parser.add_argument(
        "--index",
        help=_("El índice del espacio de trabajo. Útil si hay muchos"),
        type=int,
        default=0

    )

    subparsers = parser.add_subparsers(help=_("plugins actuales"))
    list_plugins = pathlib.Path(server_conf.get("plugins")).iterdir()

    for plugin_path in list_plugins:
        if not (plugin_path.is_dir()):
            continue

        if (plugin_path.as_posix().endswith("-%s" % (defaults.shared_dir_extension))):
            continue

        plugin_name = os.path.basename(plugin_path.as_posix())
        plugin_abs = os.path.join(plugin_path.as_posix(), plugin_name)
        plugin_module = plugin_abs + ".py"

        # Si es un archivo de configuración, se ignora
        if (plugin_abs.endswith("-%s" % (defaults.config_extension))):
            continue

        if not (os.path.isfile(plugin_module)):
            logging.warning(_(
                "'%s' debería estar en '%s'"
                
            ), plugin_module, plugin_path.as_posix())
            continue

        if not (plugin_exists):
            # Indicamos que hay plugins ya que estamos iterando
            plugin_exists = True

        plugin_fileconfig = "%s-%s" % (
            plugin_abs, defaults.config_extension
            
        )

        if not (os.path.isfile(plugin_fileconfig + ".py")):
            logging.warning(_(
                "No hay archivo de configuración para el plugin '%s'"
                
            ), plugin_name)
            continue

        try:
            plugin_config = config.get_config(plugin_fileconfig)

        except Exception as err:
            logging.warning(
                _("Excepción captada al leer el archivo de configuración del plugin '%s'"),
                plugin_name, exc_info=True
                
            )
            print()
            continue

        subparser = subparsers.add_parser(
            plugin_name,
            help=plugin_config.get("description"),
            add_help=False

        )

        subparser.add_argument(
            "-h", "--help", action="help", help=_("Imprimir este mensaje y salir")

        )
        
        # Información necesaria para cuando se termine de analizar la configuración.
        #
        # Se coloca como un diccionario para no interferir con algún que otro parámetro
        # cuando se le pase a la función principal del plugin.
        subparser.set_defaults(__OPTIONS__={
            "filename"   : plugin_abs,
            "persist"    : plugin_config.get("persist"),
            "workspaces" : plugin_config.get("workspaces")
            
        })

        if (plugin_config.get("version") is not None):
            subparser.add_argument(
                "--version",
                action="version",
                version=plugin_config.get("version"),
                help=_("muestra la versión del programa y sale")

            )

        for command in plugin_config.get("commands"):
            for group_name, params in command.items():
                try:
                    isinstance_multiple.instance_by((group_name, params), (str, list))

                except AssertionError:
                    logging.warning(_(
                        "El tipo de dato del nombre del grupo '%s' o "
                        "el de los parámetros de éste en el plugin "
                        "'%s' no es correcto" 
                        
                    ), group_name, plugin_name)

                    break

                if (group_name.lower() in ("optionals", "positionals")):
                    parser_obj = subparser

                else:
                    parser_obj = subparser.add_argument_group(
                        group_name

                    )

                for n, param in enumerate(params, 1):
                    if not (isinstance(param, dict)):
                        logging.warning(_(
                            "El tipo de dato de los argumentos identificados "
                            "por el número '%d' no son correctos en el grupo "
                            "'%s' sobre el plugin '%s'" 
                            
                        ), n, group_name, plugin_name)
                        break

                    try:
                        args = param.pop("args")

                    except KeyError:
                        logging.warning(_(
                            "¡Los parámetros del grupo '%s' en el plugin '%s' "
                            "no cuentan con una clave necesaria!" 
                            
                        ), group_name, plugin_name)
                        break

                    try:
                        if (param.get("help")):
                            param["help"] = param.get("help")

                        parser_obj.add_argument(*args, **param)

                    except Exception as err:
                        logging.exception(
                            _("Ocurrió una excepción al agregar el plugin '%s'"), plugin_name
                            
                        )

                        break

    if not (plugin_exists):
        logging.info(_("Aún no hay plugins..."))
        return

    args = parser.parse_args()

    if (args.version):
        print(args.version)
        sys.exit(0)

    if not (hasattr(args, "__OPTIONS__")):
        print_help(parser, None)

    # Primero se ejecutan las instrucciones SQL
    init_db.init(database, args.sql_file)

    # Ahora obtenemos las opciones del plugin
    options = args.__OPTIONS__

    function = config.get_function(
        (
            args.no_add_path,
            args.no_restore,
            args.index,
            args.path
            
        ),
        options
        
    )

    if (options.get("persist")):
        is_persist = True

        ioloop.add_callback(function, args)

    else:
        await execute_possible_coroutine.execute(
            function, args

        )

if __name__ == "__main__":
    try:
        loop = asyncio.get_event_loop()
        loop.run_until_complete(main())

        if (is_persist):
            ioloop.start()

    except KeyboardInterrupt:
        pass

    except Exception as err:
        logging.exception(_("¡Excepción captada en tiempo de ejecución!"))

    finally:
        ioloop.stop()