source: ogAgent-Git/ogcore-mock.py @ b7b2a58

from flask import Flask, request, jsonify, render_template_string, abort
import os
import logging
import json
import subprocess
import base64

## FLASK_APP=/path/to/ogcore-mock.py FLASK_ENV=development FLASK_RUN_CERT=adhoc sudo --preserve-env flask run --host 192.168.1.249 --port 443


app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

## agente lin/win/mac

@app.route('/opengnsys/rest/ogagent/<cucu>', methods=['POST'])
def og_agent(cucu):
    logging.info(f'{request.get_json()}')
    return jsonify({})



## agente oglive: modulo ogAdmClient

@app.route('/opengnsys/rest/ogAdmClient/InclusionCliente', methods=['POST'])
def inclusion_cliente():
    logging.info(f'{request.get_json()}')
    #procesoInclusionCliente() or { return (jsonify { 'res': 0 }) }
    j = request.get_json(force=True)
    iph = j['iph']  ## Toma ip
    cfg = j['cfg']  ## Toma configuracion
    logging.info(f'iph ({iph}) cfg ({cfg})')

    # dbi->query (sprintf "SELECT ordenadores.*,aulas.idaula,centros.idcentro FROM ordenadores INNER JOIN aulas ON aulas.idaula=ordenadores.idaula INNER JOIN centros ON centros.idcentro=aulas.idcentro WHERE ordenadores.ip = '%s'", iph);
    # if (!dbi_result_next_row(result)) { log_error ('client does not exist in database') }
    # log_debug (sprintf 'Client %s requesting inclusion', iph);

    idordenador     = 42              #dbi_result_get_uint(result, "idordenador")
    nombreordenador = 'hal9000'       #dbi_result_get_string(result, "nombreordenador");
    cache           = 42              #dbi_result_get_uint(result, "cache");
    idproautoexec   = 42              #dbi_result_get_uint(result, "idproautoexec");
    idaula          = 42              #dbi_result_get_uint(result, "idaula");
    idcentro        = 42              #dbi_result_get_uint(result, "idcentro");

    # resul = actualizaConfiguracion(dbi, cfg, idordenador);    ## Actualiza la configuración del ordenador
    # if (!resul) { log_error ('Cannot add client to database') }
    # if (!registraCliente(iph)) { log_error ('client table is full') }     ## Incluyendo al cliente en la tabla de sokets

    return jsonify({
        'res': 1,                 ## int, Confirmación proceso correcto
        'ido': idordenador,       ## int
        'npc': nombreordenador,   ## string
        'che': cache,             ## int
        'exe': idproautoexec,     ## int
        'ida': idaula,            ## int
        'idc': idcentro           ## int
    })

def _recorreProcedimientos(parametros, fileexe, idp):
    #char idprocedimiento[LONPRM];
    #int procedimientoid, lsize;
    #const char *msglog, *param;
    #dbi_result result;

    #dbi->query (sprintf 'SELECT procedimientoid,parametros FROM procedimientos_acciones WHERE idprocedimiento=%s ORDER BY orden', $idp);
    #if (!result) { log_error ('failed to query database'); return 0; }
    if 1: #while (dbi_result_next_row(result)) {
        procedimientoid = 0                      ## dbi_result_get_uint(result, "procedimientoid");
        if (procedimientoid > 0):                ## Procedimiento recursivo
            if (not _recorreProcedimientos (parametros, fileexe, procedimientoid)):
                return 0
        else:
            #param = '@'.join (["nfn=EjecutarScript\rscp=uptime", "nfn=EjecutarScript\rscp=cat /proc/uptime"])         ## dbi_result_get_string(result, "parametros");
            param = '@'.join (["nfn=popup\rtitle=my title\rmessage=my message"])
            parametros = '{}@'.format (param)
            fileexe.write (parametros)
    #}

    return 1

@app.route('/opengnsys/rest/ogAdmClient/AutoexecCliente', methods=['POST'])
def autoexec_client():
    logging.info(f'{request.get_json()}')
    j = request.get_json(force=True)
    iph = j['iph']  ## Toma dirección IP del cliente
    exe = j['exe']  ## Toma identificador del procedimiento inicial
    logging.info(f'iph ({iph}) exe ({exe})')

    fileautoexec = '/tmp/Sautoexec-{}'.format(iph)
    logging.info ('fileautoexec ({})'.format (fileautoexec));
    try:
        fileexe = open (fileautoexec, 'w')
    except Exception as e:
        logging.error ('cannot create temporary file: {}'.format (e))
        return jsonify({})

    if (_recorreProcedimientos ('', fileexe, exe)):
        res = jsonify ({ 'res': 1, 'nfl': fileautoexec })
    else:
        res = jsonify ({ 'res': 0 })

    fileexe.close()
    return res

@app.route('/opengnsys/rest/ogAdmClient/enviaArchivo', methods=['POST'])
def envia_archivo():
    logging.info(f'{request.get_json()}')
    j = request.get_json(force=True)
    nfl = j['nfl']  ## Toma nombre completo del archivo
    logging.info(f'nfl ({nfl})')

    contents = subprocess.run (['cat', nfl], capture_output=True).stdout
    b64 = base64.b64encode (contents).decode ('utf-8')
    return jsonify({'contents': b64})

def clienteExistente(iph):
    ## esto queda totalmente del lado del servidor, no lo implemento en python
    return 42

def buscaComandos(ido):
    #dbi->query (sprintf "SELECT sesion, parametros FROM acciones WHERE idordenador=%s AND estado='%d' ORDER BY idaccion", ido, ACCION_INICIADA);
    #dbi_result_next_row(result)       ## cogemos solo una fila

    #if not row { return; }
    return

    #ids   = 42                                                 #dbi_result_get_uint(result, "sesion");
    #param = "nfn=popup\rtitle=my title\rmessage=my message"    #dbi_result_get_string(result, "parametros");
    ## convertirlo a json, aqui lo pongo a capon
    #return jsonify ({ 'nfn': 'popup', 'title': 'my title', 'message': 'my message', 'ids': ids })

@app.route('/opengnsys/rest/ogAdmClient/ComandosPendientes', methods=['POST'])
def comandos_pendientes():
    logging.info(f'{request.get_json()}')
    j = request.get_json(force=True)
    iph = j['iph']  ## Toma dirección IP
    ido = j['ido']  ## Toma identificador del ordenador
    logging.info(f'iph ({iph}) ido ({ido})')

    idx = clienteExistente(iph)      ## Busca índice del cliente
    if not idx:
        ## que devuelvo?? pongamos un 404...
        abort(404, 'Client does not exist')

    param = buscaComandos(ido)       ## Existen comandos pendientes, buscamos solo uno
    if param is None:
        return jsonify({'nfn': 'NoComandosPtes'})

    #strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO);    ## esto queda totalmente del lado del servidor, no lo implemento en python

    return jsonify(param)

@app.route('/opengnsys/rest/ogAdmClient/DisponibilidadComandos', methods=['POST'])
def disponibilidad_comandos():
    logging.info(f'{request.get_json()}')
    j = request.get_json(force=True)
    iph = j['iph']
    tpc = j['tpc']
    logging.info(f'iph ({iph}) tpc ({tpc})')

    idx = clienteExistente(iph)      ## Busca índice del cliente
    if not idx:
        ## que devuelvo?? pongamos un 404...
        abort(404, 'Client does not exist')

    #strcpy(tbsockets[idx].estado, tpc);        ## esto queda totalmente del lado del servidor, no lo implemento en python

    return jsonify({})

@app.route('/opengnsys/rest/ogAdmClient/recibeArchivo', methods=['POST'])
def oac_recibe_archivo():
    logging.info(f'{request.get_json()}')
    j = request.get_json(force=True)
    nfl      = j['nfl']
    contents = j['contents']
    logging.info(f'nfl ({nfl}) contents ({contents})')
    dec = base64.b64decode (contents).decode ('utf-8')
    logging.info(f'dec ({dec})')
    return jsonify({'anything':'anything'})   ## if we return {}, then we trigger "if not {}" which happens to be true

@app.route('/opengnsys/rest/ogAdmClient/callback', methods=['POST'])
def oac_callback():
    logging.info(f'{request.get_json()}')
    return jsonify({'anything':'anything'})

@app.route('/opengnsys/rest/ogAdmClient/<cucu>', methods=['GET', 'POST'])
def oac_cucu(cucu):
    #j = request.get_json(force=True)
    #logging.info(f'{request.get_json()} {j}')
    #if 'cucu' not in j:
    #    abort(400, 'missing parameter 'cucu'')
    #return jsonify({'cucu': j['cucu']})
    abort (404)



## agente oglive: modulo CloningEngine

@app.route('/opengnsys/rest/CloningEngine/recibeArchivo', methods=['POST'])
def ce_recibe_archivo():
    logging.info(f'{request.get_json()}')
    j = request.get_json(force=True)
    nfl      = j['nfl']
    contents = j['contents']
    logging.info(f'nfl ({nfl}) contents ({contents})')
    dec = base64.b64decode (contents).decode ('utf-8')
    logging.info(f'dec ({dec})')
    return jsonify({'anything':'anything'})   ## if we return {}, then we trigger "if not {}" which happens to be true

@app.route('/opengnsys/rest/CloningEngine/callback', methods=['POST'])
def ce_callback():
    logging.info(f'{request.get_json()}')
    return jsonify({'anything':'anything'})

@app.route('/opengnsys/rest/CloningEngine/<cucu>', methods=['GET', 'POST'])
def ce_cucu(cucu):
    abort (404)



@app.errorhandler(404)
def _page_not_found(e):
    if type(e.description) is dict:
        return jsonify (e.description), e.code
    else:
        return render_template_string('''<!DOCTYPE html><html>not found</html>'''), e.code

@app.errorhandler(500)
def _internal_server_error(e):
    return render_template_string('''<!DOCTYPE html><html>err</html>'''), e.code

@app.errorhandler(Exception)
def _exception(e):
    print(e)
    return render_template_string('''<!DOCTYPE html><html>exception</html>'''), e.code

if __name__ == '__main__':
    app.run(host = '192.168.1.249', port = 443, debug=True)