CHANGELOG.md

@@ -6,18 +6,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [4.0.0] - 2025-04-24
-
-### Added
-
-- Authn/authz to the oglive agent
-
-## [3.3.0] - 2025-04-14
-
-### Added
-
-- Log stuff to a new json log
-
 ## [3.2.0] - 2025-04-10
 
 ### Added

linux/debian/changelog

@@ -1,21 +1,3 @@
-ogagent (4.0.0-1) stable; urgency=medium
-
-  * Handle authn/authz in the oglive agent
-
- -- OpenGnsys developers <info@opengnsys.es>  Thu, 24 Apr 2025 13:28:57 +0200
-
-ogagent (3.3.0-1) stable; urgency=medium
-
-  * Create an additional json log file
-
- -- OpenGnsys developers <info@opengnsys.es>  Mon, 14 Apr 2025 13:50:32 +0200
-
-ogagent (3.2.0-1) stable; urgency=medium
-
-  * Operating system: periodically ping ogcore
-
- -- OpenGnsys developers <info@opengnsys.es>  Thu, 10 Apr 2025 11:37:35 +0200
-
 ogagent (3.1.0-1) stable; urgency=medium
 
   * Oglive: periodically ping ogcore

src/VERSION

@@ -1 +1 @@
-4.0.0
+3.1.0

src/opengnsys/RESTApi.py

@@ -58,12 +58,8 @@ class ConnectionError(RESTError):
 # Disable warnings log messages
 try:
     import urllib3  # @UnusedImport
-    requests_log = logging.getLogger ('urllib3')
-    requests_log.setLevel (logging.INFO)
 except Exception:
     from requests.packages import urllib3  # @Reimport
-    requests_log = logging.getLogger ('requests.packages.urllib3')
-    requests_log.setLevel (logging.INFO)
 
 try:
     urllib3.disable_warnings()  # @UndefinedVariable
@@ -152,9 +148,7 @@ class REST(object):
                 raise Exception (f'response content-type is not "application/json" but "{ct}"')
             r = json.loads(r.content)  # Using instead of r.json() to make compatible with old requests lib versions
         except requests.exceptions.RequestException as e:
-            code = e.response.status_code
-            logger.warning (f'request failed, HTTP code "{code}"')
-            return None
+            raise ConnectionError(e)
         except Exception as e:
             raise ConnectionError(exceptionToMessage(e))
 
@@ -166,13 +160,13 @@ class REST(object):
         @param data: if None or omitted, message will be a GET, else it will send a POST
         @param processData: if True, data will be serialized to json before sending, else, data will be sent as "raw" 
         """
-        #logger.debug('Invoking post message {} with data {}'.format(msg, data))
+        logger.debug('Invoking post message {} with data {}'.format(msg, data))
 
         if processData and data is not None:
             data = json.dumps(data)
 
         url = self._getUrl(msg)
-        #logger.debug('Requesting {}'.format(url))
+        logger.debug('Requesting {}'.format(url))
 
         try:
             res = self._request(url, data)

src/opengnsys/linux/log.py

@@ -34,8 +34,6 @@ import logging
 import os
 import tempfile
 
-from ..log_format import JsonFormatter
-
 # Logging levels
 OTHER, DEBUG, INFO, WARN, ERROR, FATAL = (10000 * (x + 1) for x in range(6))
 
@@ -50,25 +48,15 @@ class LocalLogger(object):
 
         for logDir in ('/var/log', os.path.expanduser('~'), tempfile.gettempdir()):
             try:
-                fname1 = os.path.join (logDir, 'opengnsys.log')
-                fmt1 = logging.Formatter (fmt='%(levelname)s %(asctime)s (%(threadName)s) (%(funcName)s) %(message)s')
-                fh1 = logging.FileHandler (filename=fname1, mode='a')
-                fh1.setFormatter (fmt1)
-                fh1.setLevel (logging.DEBUG)
-
-                fname2 = os.path.join (logDir, 'opengnsys.json.log')
-                fmt2 = JsonFormatter ({"timestamp": "asctime", "severity": "levelname", "threadName": "threadName", "function": "funcName", "message": "message"}, time_format='%Y-%m-%d %H:%M:%S', msec_format='')
-                fh2 = logging.FileHandler (filename=fname2, mode='a')
-                fh2.setFormatter (fmt2)
-                fh2.setLevel (logging.DEBUG)
-
-                self.logger = logging.getLogger ('opengnsys')
-                self.logger.setLevel (logging.DEBUG)
-                self.logger.addHandler (fh1)
-                self.logger.addHandler (fh2)
-
-                os.chmod (fname1, 0o0600)
-                os.chmod (fname2, 0o0600)
+                fname = os.path.join(logDir, 'opengnsys.log')
+                logging.basicConfig(
+                    filename=fname,
+                    filemode='a',
+                    format='%(levelname)s %(asctime)s (%(threadName)s) (%(funcName)s) %(message)s',
+                    level=logging.DEBUG
+                )
+                self.logger = logging.getLogger('opengnsys')
+                os.chmod(fname, 0o0600)
                 return
             except Exception:
                 pass

src/opengnsys/log_format.py

@@ -1,55 +0,0 @@
-import json
-import logging
-
-class JsonFormatter(logging.Formatter):
-    """
-    Formatter that outputs JSON strings after parsing the LogRecord.
-
-    @param dict fmt_dict: Key: logging format attribute pairs. Defaults to {"message": "message"}.
-    @param str time_format: time.strftime() format string. Default: "%Y-%m-%dT%H:%M:%S"
-    @param str msec_format: Microsecond formatting. Appended at the end. Default: "%s.%03dZ"
-    """
-    def __init__(self, fmt_dict: dict = None, time_format: str = "%Y-%m-%dT%H:%M:%S", msec_format: str = "%s.%03dZ"):
-        self.fmt_dict = fmt_dict if fmt_dict is not None else {"message": "message"}
-        self.default_time_format = time_format
-        self.default_msec_format = msec_format
-        self.datefmt = None
-
-    def usesTime(self) -> bool:
-        """
-        Overwritten to look for the attribute in the format dict values instead of the fmt string.
-        """
-        return "asctime" in self.fmt_dict.values()
-
-    def formatMessage(self, record) -> dict:
-        """
-        Overwritten to return a dictionary of the relevant LogRecord attributes instead of a string.
-        KeyError is raised if an unknown attribute is provided in the fmt_dict.
-        """
-        return {fmt_key: record.__dict__[fmt_val] for fmt_key, fmt_val in self.fmt_dict.items()}
-
-    def format(self, record) -> str:
-        """
-        Mostly the same as the parent's class method, the difference being that a dict is manipulated and dumped as JSON
-        instead of a string.
-        """
-        record.message = record.getMessage()
-
-        if self.usesTime():
-            record.asctime = self.formatTime(record, self.datefmt)
-
-        message_dict = self.formatMessage(record)
-
-        if record.exc_info:
-            # Cache the traceback text to avoid converting it multiple times
-            # (it's constant anyway)
-            if not record.exc_text:
-                record.exc_text = self.formatException(record.exc_info)
-
-        if record.exc_text:
-            message_dict["exc_info"] = record.exc_text
-
-        if record.stack_info:
-            message_dict["stack_info"] = self.formatStack(record.stack_info)
-
-        return json.dumps(message_dict, default=str)

src/opengnsys/modules/server/ogAdmClient/__init__.py

@@ -33,15 +33,14 @@
 """
 
 import base64
+#import threading
+#import time
 import os
 import signal
-import string
-import random
 import subprocess
 from pathlib import Path
 from urllib.parse import unquote
 
-from opengnsys import VERSION
 from opengnsys.log import logger
 from opengnsys.workers import ogLiveWorker
 
@@ -51,41 +50,22 @@ def check_secret (fnc):
     Decorator to check for received secret key and raise exception if it isn't valid.
     """
     def wrapper (*args, **kwargs):
-        try:
-            this, path, get_params, post_params, server = args
-
-            if not server:      ## this happens on startup, eg. onActivation->autoexecCliente->ejecutaArchivo->popup->check_secret
-                return fnc (*args, **kwargs)
-
-            if this.random == server.headers['Authorization']:
-                return fnc (*args, **kwargs)
-            else:
-                raise Exception ('Unauthorized operation')
-        except Exception as e:
-            logger.error (str (e))
-            raise Exception (e)
+        return fnc (*args, **kwargs)
+        #try:
+        #    this, path, get_params, post_params, server = args
+        #    # Accept "status" operation with no arguments or any function with Authorization header
+        #    if fnc.__name__ == 'process_status' and not get_params:
+        #        return fnc (*args, **kwargs)
+        #    elif this.random == server.headers['Authorization']:
+        #        return fnc (*args, **kwargs)
+        #    else:
+        #        raise Exception ('Unauthorized operation')
+        #except Exception as e:
+        #    logger.error (str (e))
+        #    raise Exception (e)
 
     return wrapper
 
-# Check if operation is permitted
-def execution_level(level):
-    def check_permitted(fnc):
-        def wrapper(*args, **kwargs):
-            levels = ['status', 'halt', 'full']
-            this = args[0]
-            try:
-                if levels.index(level) <= levels.index(this.exec_level):
-                    return fnc(*args, **kwargs)
-                else:
-                    raise Exception('Unauthorized operation')
-            except Exception as e:
-                logger.debug (str(e))
-                raise Exception(e)
-
-        return wrapper
-
-    return check_permitted
-
 class ogAdmClientWorker (ogLiveWorker):
     name          = 'ogAdmClient'  # Module name
     REST          = None  # REST object
@@ -98,6 +78,60 @@ class ogAdmClientWorker (ogLiveWorker):
         self.REST.sendMessage ('ogAdmClient/stopped', {'mac': self.mac, 'ip': self.IPlocal, 'idcentro': self.idcentro, 'idaula': self.idaula,
                                                        'idordenador': self.idordenador, 'nombreordenador': self.nombreordenador})
 
+    #def processClientMessage (self, message, data):
+    #    logger.debug ('Got OpenGnsys message from client: {}, data {}'.format (message, data))
+
+    #def onLogin (self, data):
+    #    logger.warning ('in onLogin, should not happen')
+
+    #def onLogout (self, user):
+    #    logger.warning ('in onLogout, should not happen')
+
+    #@check_secret
+    #def process_reboot (self, path, get_params, post_params, server):
+    #    """
+    #    Launches a system reboot operation
+    #    :param path:
+    #    :param get_params:
+    #    :param post_params:
+    #    :param server: authorization header
+    #    :return: JSON object {"op": "launched"}
+    #    """
+    #    logger.debug ('Received reboot operation')
+
+    #    # Rebooting thread
+    #    def rebt():
+    #        operations.reboot()
+    #    threading.Thread (target=rebt).start()
+    #    return {'op': 'launched'}
+
+    #@check_secret
+    #def process_poweroff (self, path, get_params, post_params, server):
+    #    """
+    #    Launches a system power off operation
+    #    :param path:
+    #    :param get_params:
+    #    :param post_params:
+    #    :param server: authorization header
+    #    :return: JSON object {"op": "launched"}
+    #    """
+    #    logger.debug ('Received poweroff operation')
+
+    #    # Powering off thread
+    #    def pwoff():
+    #        time.sleep (2)
+    #        operations.poweroff()
+    #    threading.Thread (target=pwoff).start()
+    #    return {'op': 'launched'}
+
+    ## process_*        are invoked from opengnsys/httpserver.py:99 "data = module.processServerMessage (path, get_params, post_params, self)" (via opengnsys/workers/server_worker.py)
+    ## process_client_* are invoked from opengnsys/service.py:123   "v.processClientMessage (message, json.loads (data))"                      (via opengnsys/workers/server_worker.py)
+
+
+
+
+
+
 
 
 
@@ -168,7 +202,7 @@ class ogAdmClientWorker (ogLiveWorker):
             logger.warning ('Ha ocurrido algún problema en el proceso de inclusión del cliente')
             logger.error ('LeeConfiguracion() failed')
             return False
-        res = self.enviaMensajeServidor ('InclusionCliente', { 'cfg': self.cfg2obj (cfg), 'secret': self.random, 'agent_version': VERSION })
+        res = self.enviaMensajeServidor ('InclusionCliente', { 'cfg': self.cfg2obj (cfg) })
         logger.debug ('res ({})'.format (res))
 
         ## RESPUESTA_InclusionCliente
@@ -274,9 +308,6 @@ class ogAdmClientWorker (ogLiveWorker):
 
     def onActivation (self):
         super().onActivation()
-        self.exec_level = 'full'
-        self.random = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(32))
-
         logger.info ('Inicio de sesion')
         logger.info ('Abriendo sesión en el servidor de Administración')
         if (not self.inclusionCliente()):
@@ -303,10 +334,35 @@ class ogAdmClientWorker (ogLiveWorker):
 
         logger.info ('onActivation ok')
 
+    @check_secret
+    def process_status (self, path, get_params, post_params, server):
+        logger.debug ('in process_status, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
+        full_config = 'full-config' in post_params and post_params['full-config']
+        thr_status = {}
+        for k in self.thread_list:
+            thr_status[k] = {
+                'running': self.thread_list[k]['running'],
+                'result': self.thread_list[k]['result'],
+            }
+        ret = {
+            'nfn': 'RESPUESTA_status',
+            'mac': self.mac,
+            'st': 'OGL',
+            'ip': self.IPlocal,
+            'threads': thr_status,
+        }
+        if full_config:
+            cfg = self.LeeConfiguracion()
+            ret['cfg'] = self.cfg2obj (cfg)
+        return ret
 
-
-
-
+    @check_secret
+    def process_popup (self, path, get_params, post_params, server):
+        logger.debug ('in process_popup, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
+        logger.debug ('type(post_params) "{}"'.format (type (post_params)))
+        ## in process_popup, should not happen, path "[]" get_params "{}" post_params "{'title': 'mi titulo', 'message': 'mi mensaje'}" server "<opengnsys.httpserver.HTTPServerHandler object at 0x7fa788cb8fa0>"
+        ## type(post_params) "<class 'dict'>"
+        return {'debug':'test'}
 
     def do_CrearImagen (self, post_params):
         for k in ['dsk', 'par', 'cpt', 'idi', 'nci', 'ipr', 'nfn', 'ids']:
@@ -699,54 +755,16 @@ class ogAdmClientWorker (ogLiveWorker):
 
 
 
-
-
-    @execution_level('status')
-    def process_status (self, path, get_params, post_params, server):
-        logger.debug ('in process_status, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
-        full_config = 'full-config' in post_params and post_params['full-config']
-        thr_status = {}
-        for k in self.thread_list:
-            thr_status[k] = {
-                'running': self.thread_list[k]['running'],
-                'result': self.thread_list[k]['result'],
-            }
-        ret = {
-            'nfn': 'RESPUESTA_status',
-            'mac': self.mac,
-            'st': 'OGL',
-            'ip': self.IPlocal,
-            'threads': thr_status,
-        }
-        if full_config:
-            cfg = self.LeeConfiguracion()
-            ret['cfg'] = self.cfg2obj (cfg)
-        return ret
-
-    @check_secret
-    def process_popup (self, path, get_params, post_params, server):
-        logger.debug ('in process_popup, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
-        logger.debug ('type(post_params) "{}"'.format (type (post_params)))
-        ## in process_popup, should not happen, path "[]" get_params "{}" post_params "{'title': 'mi titulo', 'message': 'mi mensaje'}" server "<opengnsys.httpserver.HTTPServerHandler object at 0x7fa788cb8fa0>"
-        ## type(post_params) "<class 'dict'>"
-        return {'debug':'test'}
-
-    @execution_level('full')
-    @check_secret
     def process_Actualizar (self, path, get_params, post_params, server):
         logger.debug ('in process_Actualizar, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('Actualizar', self.do_Actualizar, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_Purgar (self, path, get_params, post_params, server):
         logger.debug ('in process_Purgar, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         os.kill (os.getpid(), signal.SIGTERM)
         return {}
         #exit (0)      ## ogAdmClient.c:905
 
-    @execution_level('full')
-    @check_secret
     def process_Comando (self, path, get_params, post_params, server):
         logger.debug ('in process_Comando, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('Comando', self.do_Comando, args=(post_params,))
@@ -755,14 +773,10 @@ class ogAdmClientWorker (ogLiveWorker):
         logger.debug ('in process_Sondeo, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return {}      ## ogAdmClient.c:920
 
-    @execution_level('full')
-    @check_secret
     def process_ConsolaRemota (self, path, get_params, post_params, server):
         logger.debug ('in process_ConsolaRemota, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('ConsolaRemota', self.do_ConsolaRemota, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_Arrancar (self, path, get_params, post_params, server):
         logger.debug ('in process_Arrancar, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
 
@@ -779,38 +793,26 @@ class ogAdmClientWorker (ogLiveWorker):
         }
         return self.respuestaEjecucionComando (cmd, 0, ids)
 
-    @execution_level('halt')
-    @check_secret
     def process_Apagar (self, path, get_params, post_params, server):
         logger.debug ('in process_Apagar, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('Apagar', self.do_Apagar, args=(post_params,))
 
-    @execution_level('halt')
-    @check_secret
     def process_Reiniciar (self, path, get_params, post_params, server):
         logger.debug ('in process_Reiniciar, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('Reiniciar', self.do_Reiniciar, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_IniciarSesion (self, path, get_params, post_params, server):
         logger.debug ('in process_IniciarSesion, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('IniciarSesion', self.do_IniciarSesion, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_EjecutarScript (self, path, get_params, post_params, server):
         logger.debug ('in process_EjecutarScript, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('EjecutarScript', self.do_EjecutarScript, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_EjecutaComandosPendientes (self, path, get_params, post_params, server):
         logger.debug ('in process_EjecutaComandosPendientes, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return {'true':'true'}         ## ogAdmClient.c:2138
 
-    @execution_level('full')
-    @check_secret
     def process_CrearImagen (self, path, get_params, post_params, server):
         logger.debug ('in process_CrearImagen, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         logger.debug ('type(post_params) "{}"'.format (type (post_params)))
@@ -826,8 +828,6 @@ class ogAdmClientWorker (ogLiveWorker):
     #    logger.warning ('this method has been removed')
     #    raise Exception ({ '_httpcode': 404, '_msg': 'This method has been removed' })
 
-    @execution_level('full')
-    @check_secret
     def process_RestaurarImagen (self, path, get_params, post_params, server):
         logger.debug ('in process_RestaurarImagen, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         logger.debug ('type(post_params) "{}"'.format (type (post_params)))
@@ -844,27 +844,18 @@ class ogAdmClientWorker (ogLiveWorker):
     #    logger.warning ('this method has been removed')
     #    raise Exception ({ '_httpcode': 404, '_msg': 'This method has been removed' })
 
-    ## una partición + cache en disco de 30 Gb:
-    @execution_level('full')
-    @check_secret
     def process_Configurar (self, path, get_params, post_params, server):
         logger.debug ('in process_Configurar, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('Configurar', self.do_Configurar, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_InventarioHardware (self, path, get_params, post_params, server):
         logger.debug ('in process_InventarioHardware, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('InventarioHardware', self.do_InventarioHardware, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_InventarioSoftware (self, path, get_params, post_params, server):
         logger.debug ('in process_InventarioSoftware, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         return self._long_running_job ('InventarioSoftware', self.do_InventarioSoftware, args=(post_params,))
 
-    @execution_level('full')
-    @check_secret
     def process_KillJob (self, path, get_params, post_params, server):
         logger.debug ('in process_KillJob, path "{}" get_params "{}" post_params "{}" server "{}"'.format (path, get_params, post_params, server))
         jid = post_params['job_id']

src/opengnsys/windows/log.py

@@ -36,8 +36,6 @@ import logging
 import os
 import tempfile
 
-from ..log_format import JsonFormatter
-
 # Valid logging levels, from UDS Broker (uds.core.utils.log)
 OTHER, DEBUG, INFO, WARN, ERROR, FATAL = (10000 * (x + 1) for x in range(6))
 
@@ -46,24 +44,13 @@ class LocalLogger(object):
     def __init__(self):
         # tempdir is different for "user application" and "service"
         # service wil get c:\windows\temp, while user will get c:\users\XXX\appdata\local\temp
-
-        fname1 = os.path.join (tempfile.gettempdir(), 'opengnsys.log')
-        fmt1 = logging.Formatter (fmt='%(levelname)s %(asctime)s (%(threadName)s) (%(funcName)s) %(message)s')
-        fh1 = logging.FileHandler (filename=fname1, mode='a')
-        fh1.setFormatter (fmt1)
-        fh1.setLevel (logging.DEBUG)
-
-        fname2 = os.path.join (tempfile.gettempdir(), 'opengnsys.json.log')
-        fmt2 = JsonFormatter ({"timestamp": "asctime", "severity": "levelname", "threadName": "threadName", "function": "funcName", "message": "message"}, time_format='%Y-%m-%d %H:%M:%S', msec_format='')
-        fh2 = logging.FileHandler (filename=fname2, mode='a')
-        fh2.setFormatter (fmt2)
-        fh2.setLevel (logging.DEBUG)
-
+        logging.basicConfig(
+            filename=os.path.join(tempfile.gettempdir(), 'opengnsys.log'),
+            filemode='a',
+            format='%(levelname)s %(asctime)s (%(threadName)s) (%(funcName)s) %(message)s',
+            level=logging.DEBUG
+        )
         self.logger = logging.getLogger('opengnsys')
-        self.logger.setLevel (logging.DEBUG)
-        self.logger.addHandler (fh1)
-        self.logger.addHandler (fh2)
-
         self.serviceLogger = False
 
     def log(self, level, message):

src/opengnsys/workers/oglive_worker.py

@@ -198,7 +198,7 @@ class ogLiveWorker(ServerWorker):
         progress = None
         for i in ary:
             if m := re.search (r'^\[([0-9]+)\]', i):     ## look for strings like '[10]', '[60]'
-                #logger.debug (f"matched regex, m.groups ({m.groups()})")
+                logger.debug (f"matched regex, m.groups ({m.groups()})")
                 progress = float (m.groups()[0]) / 100
         return progress
 
@@ -211,7 +211,7 @@ class ogLiveWorker(ServerWorker):
                 for k in self.thread_list:
                     elem = self.thread_list[k]
                     if 'thread' not in elem: continue
-                    #logger.debug (f'considering thread ({k})')
+                    logger.debug (f'considering thread ({k})')
 
                     if self.pid_q:
                         if not self.pid_q.empty():
@@ -240,20 +240,11 @@ class ogLiveWorker(ServerWorker):
             time.sleep (1)
             n += 1
             if not n % 10:
-                alive_threads = []
-                for k in self.thread_list:
-                    elem = self.thread_list[k]
-                    if 'thread' not in elem: continue
-                    alive_threads.append (k)
-                if alive_threads:
-                    s = ','.join (alive_threads)
-                    logger.debug (f'alive threads: {s}')
-
                 body = {
                     'iph': self.IPlocal,
                     'timestamp': int (time.time()),
                 }
-                #logger.debug (f'about to send ping ({body})')
+                logger.debug (f'about to send ping ({body})')
                 self.REST.sendMessage ('clients/status/webhook', body)
 
     def interfaceAdmin (self, method, parametros=[]):
@@ -286,8 +277,7 @@ class ogLiveWorker(ServerWorker):
             self.pid_q.put (p.pid)
         else:
             ## esto sucede por ejemplo cuando arranca el agente, que estamos en interfaceAdmin() en el mismo hilo, sin _long_running_job ni hilo separado
-            #logger.debug ('no queue--not writing any PID to it')
-            pass
+            logger.debug ('no queue--not writing any PID to it')
 
         sout = serr = ''
         while p.poll() is None:
@@ -303,12 +293,12 @@ class ogLiveWorker(ServerWorker):
         serr = serr.strip()
 
         ## DEBUG
-        logger.debug (f'stdout follows:')
+        logger.info (f'stdout follows:')
         for l in sout.splitlines():
-            logger.debug (f'  {l}')
-        #logger.debug (f'stderr follows:')
-        #for l in serr.splitlines():
-        #    logger.debug (f'  {l}')
+            logger.info (f'  {l}')
+        logger.info (f'stderr follows:')
+        for l in serr.splitlines():
+            logger.info (f'  {l}')
         ## /DEBUG
         if 0 != p.returncode:
             cmd_txt = ' '.join (proc)
@@ -347,7 +337,9 @@ class ogLiveWorker(ServerWorker):
         res = self.REST.sendMessage ('/'.join ([self.name, path]), obj)
 
         if (type (res) is not dict):
-            logger.error (f'response is not a dict ({res})')
+            #logger.error ('No se ha podido establecer conexión con el Servidor de Administración')   ## Error de conexión con el servidor
+            logger.debug (f'res ({res})')
+            logger.error ('Error al enviar trama ***send() fallo')
             return False
 
         return res
@@ -374,7 +366,9 @@ class ogLiveWorker(ServerWorker):
         p = subprocess.Popen (['/usr/bin/browser', '-qws', url])
         try:
             p.wait (2)       ## if the process dies before 2 seconds...
-            logger.error ('Error al ejecutar browser, return code "{}"'.format (p.returncode))
+            logger.error ('Error al ejecutar la llamada a la interface de administración')
+            logger.error ('Error en la creación del proceso hijo')
+            logger.error ('return code "{}"'.format (p.returncode))
             return False
         except subprocess.TimeoutExpired:
             pass
@@ -394,7 +388,7 @@ class ogLiveWorker(ServerWorker):
             logger.error (e)
             logger.error ('No se ha podido recuperar la dirección IP del cliente')
             return None
-        #logger.debug ('parametroscfg ({})'.format (parametroscfg))
+        logger.debug ('parametroscfg ({})'.format (parametroscfg))
         return parametroscfg
 
     def cfg2obj (self, cfg):