NuevoProyecto ETAPEProyecto Emuframe Tape Server (ETAPE)
Python

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams

Esta entrada cierra el círculo de las últimas entradas del blog. Cada una montaba una pieza por separado; aquí las junto en un proceso automático: un job programado con $TA que ejecuta un script de Python, comprueba los dispositivos con D M=CONFIG y avisa en Microsoft Teams si alguno no está como debería.

Las piezas, en el orden en que salieron:

  1. pySDSF en z/OS 3.2: vigilar el spool y avisar por Microsoft Teams: lanzar comandos desde la consola de SDSF con Python y mandar una tarjeta a Teams con post_to_teams(). Aquí el comando es D M=CONFIG(01) en lugar de $D SPOOL.
  2. Crear usuario para scripts Python en batch (RACF): el usuario PYBATCH, con el que se ejecuta el job, y el perfil SURROGAT que permite enviar jobs con su usuario.
  3. Python en z/OS: entorno virtual (venv y pyproject.toml): el entorno virtual de PYBATCH, donde están instalados pySDSF y spool_alert.
  4. Comandos automáticos en z/OS: programar comandos con $TA - JES2: los comandos automáticos de JES2, que aquí lanzan el job cada cierto tiempo.
  5. D M=CONFIG: detectar desviaciones en estado de dispositivos: comparar los dispositivos con un miembro CONFIGxx. Allí terminé diciendo que lo adecuado era incluirlo en algún proceso automatizado que nos avise si IEE097I muestra unidades en un estado que no es el esperado. Es lo que hago en esta entrada.
  6. Python en z/OS: enviar jobs desde un script y recibir el resultado en Microsoft Teams: un script que envía un job. Aquí es al revés: un comando programado envía el job que ejecuta el script.

Todo en z/OS 3.2 (stock image). La entrada de D M=CONFIG la hice en el ADCD de z/OS 3.1, así que aquí empiezo creando el CONFIG01 de este sistema.

Cómo encaja todo

$TA solo lanza comandos, no envía jobs. Para que un comando acabe enviando un job, hace falta un procedimiento que copie el JCL al lector interno de JES2 (INTRDR). La cadena queda así:

  1. Cada cierto tiempo, el comando automático lanza $VS,'S SUBMIT,...', que pasa a MVS el comando S SUBMIT.
  2. El procedimiento SUBMIT copia el miembro CFGCHK al lector interno. Corre con el usuario IBMUSER.
  3. El job CFGCHK lleva USER=PYBATCH y ejecuta el script con BPXBATCH.
  4. El script lanza D M=CONFIG(01) y, si IEE097I muestra alguna desviación, manda una tarjeta a Microsoft Teams. Si no hay ninguna, no avisa.

CONFIG01 en la stock image

La stock image no trae ningún CONFIGxx. Para saber dónde crearlo, miro la concatenación de PARMLIB:

D PARMLIB
RESPONSE=VS01
 IEE251I 14.07.19 PARMLIB DISPLAY 968
  PARMLIB DATA SETS SPECIFIED
  AT IPL
  ENTRY  FLAGS  VOLUME  DATA SET
    1      S    USRVS1  USER.PARMLIB
    2      S    USRVS1  VENDOR.PARMLIB
    3      S    OPEVS1  SYS1.PARMLIB
    4      S    Z32VS1  SYS1.PARMLIB.INSTALL

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 1

La primera es USER.PARMLIB, así que CONFIG01 va ahí. Para saber qué dispositivos poner, miro los discos y las cintas:

D U,DASD,ONLINE
D U,TAPE

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 2

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 3

Pongo los discos de DE25 a DE34 (todos online) y la unidad de cinta 0580, que es la que usaré para provocar la desviación: está online, sin cinta montada (NRD) y nadie la tiene asignada. Como en la entrada de D M=CONFIG, para una prueba hay que elegir un dispositivo que no sea disruptivo.

Creo el miembro con IEBUPDTE:

//MKCFG01  JOB (ACCT),'CREATE CONFIG01',CLASS=A,MSGCLASS=X,
//             NOTIFY=&SYSUID
//* Add member CONFIG01 to USER.PARMLIB
//ADD      EXEC PGM=IEBUPDTE,PARM=NEW
//SYSPRINT DD SYSOUT=*
//SYSUT2   DD DSN=USER.PARMLIB,DISP=SHR
//SYSIN    DD *
./ ADD NAME=CONFIG01
* CONFIG01 - expected device configuration (stock image VS01)
* System volumes
DEV DE25-DE34,ONLINE
* Tape drive used for the test
DEV 0580,ONLINE
./ ENDUP
/*

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 4

Y lo compruebo:

D M=CONFIG(01)
RESPONSE=VS01
 IEE097I 14.47.16 DEVIATION STATUS 119
                FROM MEMBER CONFIG01
         NO DEVIATION FROM REQUESTED CONFIGURATION

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 5

El script

El script, config_check.py, recibe el sufijo del miembro como argumento (00 si no recibe ninguno), lanza D M=CONFIG(xx) y lee la respuesta:

#!/usr/bin/env python3
"""Compare devices with a CONFIGxx member (D M=CONFIG) and alert Teams on deviations."""
import os
import re
import sys
from datetime import datetime

from pysdsf import Connection
from pysdsf.isfexception import ISFException
from spool_alert import post_to_teams

SUFFIX_PATTERN = re.compile(r"[A-Z0-9]{2}")
NO_DEVIATION = "NO DEVIATION FROM REQUESTED CONFIGURATION"
DESIRED_STATES = {"ONLINE", "OFFLINE"}  # what a DEV statement can ask for


def config_deviations(connection, suffix):
    """Issue D M=CONFIG(xx) and return the deviations listed in IEE097I."""
    console = connection.console()
    result = console.issue_command([f"D M=CONFIG({suffix})"],
                                   console_name_change=True, delay=1)
    lines = [str(line) for line in result]
    response = "\n".join(lines)
    if "IEE097I" not in response:
        raise RuntimeError("IEE097I not found in the command response:\n"
                           + response + f"\nSDSF messages: {console.get_message()}")
    if NO_DEVIATION in response:
        return []
    # After a header such as "DEVICE DESIRED ACTUAL", each row is one deviation:
    # "0580  ONLINE  OFFLINE" or "0340  ONLINE  NOT GEND"
    deviations = []
    kind = None
    for line in lines:
        words = line.split()
        if words[-2:] == ["DESIRED", "ACTUAL"]:
            kind = " ".join(words[:-2])
        elif kind and len(words) >= 3 and words[1] in DESIRED_STATES:
            deviations.append(f"{kind} {words[0]}: desired {words[1]}, "
                              f"actual {' '.join(words[2:])}")
    if not deviations:
        # For example NO DEVIATION COMPARISONS MADE: nothing was compared
        raise RuntimeError("IEE097I has no deviation list:\n" + response)
    return deviations


def main():
    url = os.environ.get("TEAMS_WEBHOOK_URL")
    if not url:
        sys.exit("TEAMS_WEBHOOK_URL is not set")
    suffix = (sys.argv[1] if len(sys.argv) > 1 else "00").upper()
    if not SUFFIX_PATTERN.fullmatch(suffix):
        sys.exit(f"Not a valid CONFIGxx suffix: {suffix}")

    connection = Connection()
    try:
        checked = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        deviations = config_deviations(connection, suffix)
    except ISFException as e:
        sys.exit(f"SDSF error: {e}")
    finally:
        connection.close()

    if not deviations:
        print(f"{checked} No deviation from CONFIG{suffix}")
        return 0
    for deviation in deviations:
        print(f"{checked} {deviation}")
    status = post_to_teams(url, f"{os.uname().nodename}: deviation from CONFIG{suffix}",
                           [f"Checked at {checked}"] + deviations)
    print(f"Teams answered HTTP {status}")
    return 0


if __name__ == "__main__":
    sys.exit(main())

Paso a paso:

Lanzar el comando

connection.console() abre la consola extendida de SDSF del usuario, y issue_command() lanza el comando y devuelve las líneas de la respuesta. Es lo mismo que hace spool_alert.py con $D SPOOL. Antes de meter el sufijo en el comando, el script comprueba que son dos letras o números: así no se puede colar otro texto en el comando a través del argumento.

Si en la respuesta no aparece IEE097I (por ejemplo, porque el usuario no tiene permiso para el comando), el script termina con un error y escribe todo lo que ha recibido. Así se ve el motivo en el STDERR del job.

Leer IEE097I

Si todo está como dice el miembro, IEE097I dice NO DEVIATION FROM REQUESTED CONFIGURATION y el script no tiene nada que avisar. Busco el texto completo porque IEE097I tiene otro mensaje que empieza igual, NO DEVIATION COMPARISONS MADE, que sale cuando no se ha podido comparar nada (según IBM, cuando los parámetros no contienen datos válidos). Ese caso no es un «todo bien».

Si hay desviaciones, IEE097I las muestra en una tabla con una cabecera y una línea por elemento. Para los dispositivos, la cabecera es DEVICE DESIRED ACTUAL. Según lo que tenga el miembro, puede haber otros bloques, con su propia cabecera (por ejemplo, para canales), y hay cabeceras de dos palabras. Por eso el script guarda en kind lo que va delante de DESIRED ACTUAL en la última cabecera que ha leído y, en cada línea de debajo, toma el elemento, el estado deseado y el estado actual. El estado actual puede ser más de una palabra, como NOT GEND (el dispositivo no está definido en el IODF), y por eso se junta con el resto de la línea.

Solo cuenta como desviación una línea cuyo estado deseado sea ONLINE u OFFLINE, que es lo que puede pedir una sentencia DEV. Así, otras líneas que pueda traer la respuesta no acaban en el aviso. Y si IEE097I no dice NO DEVIATION FROM REQUESTED CONFIGURATION ni trae ninguna desviación, el script termina con error y escribe la respuesta entera.

El aviso a Teams

Solo avisa si hay desviaciones. Como en las otras entradas de Python, la URL del webhook la lee de la variable TEAMS_WEBHOOK_URL, que carga el .profile de PYBATCH, y la tarjeta se manda con post_to_teams() de spool_alert, que está instalado en el entorno virtual de PYBATCH.

La tarjeta lleva en el título el nombre del sistema y el miembro, y debajo la hora de la comprobación y una línea por desviación.

El código de retorno

El script termina con 0 haya o no desviaciones: el aviso es la tarjeta de Teams. Si no llega a hacer la comprobación (falta TEAMS_WEBHOOK_URL, el sufijo no es válido, falla SDSF, no aparece IEE097I o IEE097I no trae ni la lista ni el «no deviation») o falla el envío a Teams, termina con 1, y el paso de BPXBATCH con RC=256.

Subirlo

Lo subo en binario a /u/pybatch/scripts y, como IBMUSER desde OMVS, le pongo la misma etiqueta que a los otros scripts:

chtag -tc ISO8859-1 /u/pybatch/scripts/config_check.py
ls -T /u/pybatch/scripts/config_check.py
t ISO8859-1   T=on  /u/pybatch/scripts/config_check.py

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 6

Y, como en la entrada del usuario PYBATCH, se lo doy a PYBATCH y solo él (y su grupo) pueden leerlo:

chown PYBATCH:PYGRP /u/pybatch/scripts/config_check.py
chmod 640 /u/pybatch/scripts/config_check.py

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 7

El job CFGCHK

Un job con BPXBATCH y USER=PYBATCH, como en las entradas anteriores. Lo guardo como miembro CFGCHK de mi librería de JCL, IBMUSER.JCL, porque el procedimiento que lo enviará lo lee de ahí:

//CFGCHK   JOB (ACCT),'PYBATCH CONFIG',CLASS=A,MSGCLASS=X,
//             USER=PYBATCH,REGION=256M
//* Run config_check.py: D M=CONFIG(01) and alert Microsoft
//* Teams if a device is not as CONFIG01 says
//RUN      EXEC PGM=BPXBATCH
//STDOUT   DD SYSOUT=*
//STDERR   DD SYSOUT=*
//STDPARM  DD *
SH export LIBPATH=/u/python/py313/lib:$LIBPATH;
/u/pybatch/venv/bin/python /u/pybatch/scripts/config_check.py 01
/*

No lleva NOTIFY=: el job se lanzará solo y no hay nadie esperando el aviso de que ha terminado.

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 8

El permiso para D M

La primera vez que lo lanzo, el script termina con error. En la respuesta del comando está el motivo:

 ISF061I User PYBATCH assigned destination operator authority.
 ISF031I CONSOLE PYBATCH ACTIVATED
-D M=CONFIG(01)
 IEE345I DISPLAY  AUTHORITY INVALID, FAILED BY SECURITY PRODUCT

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 9

Los comandos de MVS están protegidos en la clase OPERCMDS. Para ver qué perfil protege D M:

RLIST OPERCMDS MVS.DISPLAY.M

En la stock image lo protege el genérico MVS.*, con UACC NONE, y PYBATCH no está en la lista de acceso.

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 10

Como hice con SDSF en la entrada del usuario PYBATCH, le doy READ en el perfil que ya existe, sin crear perfiles nuevos:

//RACFDSP  JOB (ACCT),'PERMIT MVS DISPLAY',CLASS=A,MSGCLASS=X,
//             NOTIFY=&SYSUID
//* Let PYBATCH issue MVS DISPLAY commands (D M=CONFIG) from
//* its SDSF console: READ on the existing profile MVS.*
//TSO      EXEC PGM=IKJEFT01
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 RLIST OPERCMDS MVS.* AUTHUSER
 PERMIT MVS.* CLASS(OPERCMDS) ID(PYBATCH) ACCESS(READ)
 SETROPTS RACLIST(OPERCMDS) REFRESH
 RLIST OPERCMDS MVS.* AUTHUSER
/*

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 11

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 12

Con READ en MVS.*, PYBATCH puede lanzar los comandos de MVS que piden READ, que son sobre todo los DISPLAY (y otros, como REPLY o SEND). Los que piden UPDATE o CONTROL, como VARY o CANCEL, siguen sin estar permitidos.

Probarlo con una desviación

Pongo la unidad de cinta offline y lanzo CFGCHK:

V 0580,OFFLINE

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 13

En el STDOUT del job:

2026-11-21 15:34:44 DEVICE 0580: desired ONLINE, actual OFFLINE
Teams answered HTTP 202

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 14

Y en Teams llega la tarjeta:

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 15

Lanzar el job desde un comando: el procedimiento SUBMIT

Para que $TA lance el job, necesito un procedimiento que lo envíe. La stock image trae uno en SYS1.PROCLIB, SUBMIT, que copia un miembro al lector interno con IEBGENER:

//SUBMIT   PROC DS=,M=
//         EXEC PGM=IEBGENER
//SYSIN    DD DUMMY
//SYSPRINT DD DUMMY
//SYSUT2   DD SYSOUT=(A,INTRDR)
//SYSUT1   DD DSN=&DS(&M),DISP=SHR

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 16

Con qué usuario corre lo dice su perfil de la clase STARTED:

RLIST STARTED SUBMIT.* STDATA
USER= IBMUSER
GROUP= SYS1
TRUSTED= NO
PRIVILEGED= NO
TRACE= NO

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 17

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 18

SUBMIT corre como IBMUSER, y el job lleva USER=PYBATCH. Para enviar un job con el usuario de otro, el que lo envía necesita READ en el perfil PYBATCH.SUBMIT de la clase SURROGAT. Lo creé en la entrada del usuario PYBATCH, e IBMUSER ya tiene READ:

RLIST SURROGAT PYBATCH.SUBMIT AUTHUSER

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 19

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 20

Así que no hay que crear ningún procedimiento ni cambiar nada en RACF. Lo pruebo a mano, con la cinta todavía offline:

S SUBMIT,DS=IBMUSER.JCL,M=CFGCHK
S SUBMIT,DS=IBMUSER.JCL,M=CFGCHK
$HASP100 SUBMIT   ON STCINRDR
IEF695I START SUBMIT   WITH JOBNAME SUBMIT   IS ASSIGNED TO USER IBMUSER
 , GROUP SYS1
$HASP373 SUBMIT   STARTED
IEF403I SUBMIT - STARTED - TIME=15.53.58
$HASP100 CFGCHK   ON INTRDR      PYBATCH CONFIG        FROM STC05305
SUBMIT
IEF404I SUBMIT - ENDED - TIME=15.53.58
$HASP395 SUBMIT   ENDED - RC=0000

SUBMIT arranca como IBMUSER, envía CFGCHK y termina. Después CFGCHK se ejecuta como PYBATCH, lanza el comando y encuentra la desviación:

D M=CONFIG(01)
IEE252I MEMBER CONFIG01 FOUND IN USER.PARMLIB
IEE097I 15.54.01 DEVIATION STATUS 381
               FROM MEMBER CONFIG01
DEVICE      DESIRED   ACTUAL
0580         ONLINE   OFFLINE
...
$HASP395 CFGCHK   ENDED - RC=0000

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 21

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 22

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 23

Programarlo con $TA

Para lanzar un comando de MVS desde un comando automático se usa $VS, con sus comillas simples escritas dos veces dentro de las de $TA, como contaba en la entrada de $TA. Para la prueba, cada 5 minutos:

$TA,I=300,'$VS,''S SUBMIT,DS=IBMUSER.JCL,M=CFGCHK'''

Es un comando largo y no cabe en la línea de comandos de SDSF. Si se escribe ahí, a JES2 le llega cortado: la entrada se crea igualmente, pero el comando que lanza es solo $VS,'S y JES2 responde $HASP650 'S INVALID OPERAND OR MISPLACED OPERAND. Esa entrada se queda activa y da el error cada vez que se lanza, así que hay que borrarla con $CA y su número.

Para comandos largos, SDSF tiene la ventana System Command Extension: escribiendo solo / en la línea de comandos y pulsando Intro, se abre una ventana donde cabe el comando entero. Lo escribo ahí:

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 24

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 25

JES2 responde con el mensaje $HASP604 y la entrada que ha creado, en mi caso la 8, con el comando completo. Como no lleva T=, se lanza en ese momento: en el log se ve $HASP249 COMMAND RECEIVED FROM AUTO COMMAND ID=8, el S SUBMIT y después el job CFGCHK.

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 26

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 27

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 28

Con $TA,ALL se ve la hora del siguiente lanzamiento:

$TA,ALL

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 29

Con la cinta todavía offline, cada vez que se lanza llega una tarjeta a Teams.

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 30

Sin desviaciones, sin aviso

Vuelvo a poner la cinta online:

V 0580,ONLINE

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 31

En la siguiente ejecución, IEE097I dice que no hay desviaciones, el job termina con RC=0000 y a Teams no llega nada. En el STDOUT de CFGCHK:

2026-11-21 17:26:07 No deviation from CONFIG01

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 32

Dejarlo cada hora

Cada 5 minutos está bien para probar, pero para el día a día basta con una vez cada hora. Con el identificador de la entrada, $TA la modifica:

$TA8,I=3600
$TA,ALL

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 33

Según la documentación de IBM, si JES2 falla, los comandos automáticos que no están en sus parámetros de inicialización se pierden. Para que se creen cada vez que arranca JES2, se pueden poner en esos parámetros, como explicaba en la entrada de $TA.

Para cancelar el comando:

$CA8

Lanzar un job programado con $TA: comprobar D M=CONFIG con Python y avisar en Microsoft Teams – captura 34

Resumen

  • CONFIG01 se crea en la primera PARMLIB de la concatenación (D PARMLIB), con los dispositivos que queremos vigilar.
  • config_check.py lanza D M=CONFIG(xx) desde la consola de SDSF con pySDSF, lee IEE097I y avisa por Teams solo si hay desviaciones.
  • Para lanzar D M, PYBATCH necesita READ en el perfil de OPERCMDS que lo protege; en la stock image, MVS.*.
  • $TA solo lanza comandos: con $VS arranca el procedimiento SUBMIT de la stock image, que envía el job al lector interno.
  • SUBMIT corre como IBMUSER, que tiene READ en PYBATCH.SUBMIT (SURROGAT), así que el job se ejecuta como PYBATCH sin cambiar nada más en RACF.
  • Un comando $TA largo no cabe en la línea de comandos de SDSF: se escribe en la ventana System Command Extension (/ solo).
  • Con esto, las piezas de las entradas anteriores (pySDSF, el usuario PYBATCH, su entorno virtual, $TA y D M=CONFIG) funcionan juntas: la comprobación se lanza sola y el aviso llega a Teams.

Referencias

© 2026 Emuframe·🍪 Este sitio solo usa cookies funcionales. Sin rastreo ni recopilación de datos personales.

En esta página