Your Browser is not longer supported

Please use Google Chrome, Mozilla Firefox or Microsoft Edge to view the page correctly
Loading...

{{viewport.spaceProperty.prod}}

Administration via distributed processing

If you want to handle central administration for openUTM via distributed processing, you have the following advantages:

  • Several applications can be administered simultaneously.

  • Administration jobs can be started both from the administration application itself and from the applications being administered (the polling function).

  • Time-driven administration jobs can be set up very easily (DPUT).

  • You can, if necessary, work with global transaction management. This allows you, for example, to ensure that certain application parameters are modified simultaneously for all applications, which cannot be guaranteed when administering applications via a UPIC client or a TS application (as network failures can mean that the operation cannot be performed for one of the applications while the others are already working with the new values).

You can use the LU6.1 or OSI TP protocols for communication between the administration application and the servers being administered.

Programming

If you require global transaction management for your administration operations, one transaction from the administration application will need to communicate with several job receivers. The figure below illustrates this principle using the example of two administered applications, each of which submits several administration calls.

The program TPADM sends jobs to both applications. The program TPREC is called only after responses have been received from both applications. Once both applications have completed their respective jobs properly, TPREC terminates the global transaction and the service.

The following example gives an idea of what the programs TPADM and TPREC might look like. The administrative task is, from a Unix computer, to initiate the simultaneous exchange of a program in a UTM application on a Unix or Linux system and a UTM application on a BS2000 system. Program exchange is handled differently on Unix, Linux and Windows systems and BS2000 systems, however. BS2000 systems determine the current version of the load module, marks the load module for exchange and then reloads the application. On Unix, Linux and Windows systems, the program is replaced immediately. The administered applications can use a program like the one in chapter "Several administration calls". The figure below illustrates this example for LU6.1 and OSI TP without global transaction management.

If you are using a UTM application on Windows systems, either instead of the administered or the administering UTM application on Unix or Linux systems, or both, then programming and generation are the same. Note that port number 102 cannot be used for UTM applications on Unix, Linux and Windows systems.

 /* Program unit TPADM sends data to applications UTMAPPL1 and UTMAPPL2    */
 
 INIT
 memcpy (buffer,  ...)                  /* Edit data.                      */
 APRO DM KCPI=VGID1 KCPA=UTMAPPL1       /* Address job-receiving service   */
         KCRN=TPADMIN                   /* TPADMIN in UTMAPPL1.            */
 
 MPUT NE buffer                         /* Send data to UTMAPPL1.          */
      KCRN=VGID1
  
 APRO DM KCPI=VGID2 KCPA=UTMAPPL2       /* Address job-receiving service   */
         KCRN=TPADMIN                   /* TPADMIN in UTMAPPL2.            */
  
 MPUT NE buffer                         /* Send data to UTMAPPL2.          */
      KCRN=VGID2
  
 PEND KP KCRN=TPREC                     /* Wait for job receiver.          */

For OSI TP with global transaction management, additional statements are required in order to:

  • select the commit functional unit
    (APRO... KCOF=C)

  • request UTMAPPL1 to initiate the end of the transaction and dialog
    (CTRL PE, KCRN=VGID1)

  • request UTMAPPL2 to initiate the end of the transaction and dialog
    (CTRL PE, KCRN=VGID1)

 /* Follow-up program TPREC receives confirmation from job-receiving       */
 /* service                                                                */
  
 INIT
    KCRPI=VGIDx                         /* 1st message comes from JS       */
                                        /* service with service ID VGIDx.  */
 MGET NT KCRN=VGIDx                     /* Read response from JS service 1,*/
         KCRCCC=12Z KCRPI=VGIDy         /* Further message from other JS   */
                                        /* service (VGIDy) already waiting */
 if (OK)                                /* JS service 1 has initiated      */
  {                                     /* program exchange.               */
    MGET NT KCRN=VGIDy                  /* Read response from JS service 2.*/
            KCRCCC=10Z KCRPI=SPACES     /* No further messages waiting.    */
   if (OK)                              /* JS service 2 has initiated      */
     {                                  /* program exchange   .            */
       MPUT NE                          /* Send message to administrator.  */
       PEND FI                          /* Terminate global transaction.   */
     } else error_routine();
  } else error_routine();
 ....
 error_routine ()                       /* Error routine                   */
         { MPUT NE                      /* Notify administrator            */
           PEND FR }                    /* roll back and terminate         */
                                        /* global transaction.             */

Generation example

The example shows an LU6.1 generation; the administration application uses two-level addressing.

In the example the port numbers and computer names (BS20HOST, UnixHOST, UnixADMI) are specified in the generation statements. See the openUTM manual “Generating Applications” under "Providing address information" for further information.

  1. Generation of the UTM administration application on Unix or Linux systems

    BCAMAPPL ADMINAPP,LISTENER-PORT=1234,T-PROT=RFC1006,T-SEL-FORMAT=T
    ***
    *** Connection to application on Unix or Linux system; the administrator 
    *** application is the job submitter.
    SESCHA ADMAPPL1,PLU=Y,CONNECT=Y
    LPAP UTMAPPL1,SESCHA=ADMAPPL1
    LSES ADMAG1,LPAP=UTMAPPL1,...
    CON APPLUnix,BCAMAPPL=ADMINAPP,PRONAM=UnixHOST -
                  ,LISTENER-PORT=2345,LPAP=UTMAPPL1,...
    ***
    *** Connection to application on the BS2000 system; 
    *** the administrator application is the job submitter. 
    SESCHA ADMAPPL2,PLU=Y,CONNECT=Y
    LPAP UTMAPPL2,SESCHA=ADMAPPL2
    LSES ADMAG2,LPAP=UTMAPPL2,...
    CON APPLIBS2,BCAMAPPL=ADMINAPP,PRONAM=BS20HOST -
                  ,LISTENER-PORT=102,LPAP=UTMAPPL2,...
    ***
    *** LTAC for the remote administration program; two-level addressing
    *** LTAC=RTAC is the TAC in the remote application.
    LTAC TPADMIN
    ***
    *** TACs for both administration programs
    TAC TPADM,PROGRAM=...
    TAC TPREC,PROGRAM=...
    
  2. Generation of the administered UTM application on the BS2000 system

    BCAMAPPL APPLIBS2,T-PROT=ISO
    ***
    *** LU6 generation for the job receiver
    SESCHA ADMINREC,PLU=N,CONNECT=N
    LPAP UTMADMIN,SESCHA=ADMINREC,PERMIT=ADMIN
    LSES ADMAN,LPAP=UTMADMIN,...
    CON ADMINAPP,BCAMAPPL=APPLIBS2,PRONAM=UnixADMI,LPAP=UTMADMIN,...
    ***
    TAC TPADMIN,PROGRAM=ADMINPRG,ADMIN=Y
    PROGRAM ADMINPRG,...
    

  3. Generation of the administered UTM application on Unix or Linux systems

    BCAMAPPL APPLUnix,LISTENER-PORT=1234,T-PROT=RFC1006,T-SEL-FORMAT=T
    ***
    *** LU6 generation for the job receiver
    SESCHA ADMINREC,PLU=N,CONNECT=N
    LPAP UTMADMIN,SESCHA=ADMINREC,PERMIT=ADMIN
    LSES ADMAN,LPAP=UTMADMIN,...
    CON ADMINAPP,BCAMAPPL=APPLUnix,PRONAM=UnixADMI -
                  ,LISTENER-PORT=2345,LPAP=UTMADMIN,...
    ***
    TAC TPADMIN,PROGRAM=ADMINPRG,ADMIN=Y
    PROGRAM ADMINPRG,...