C400

106. API : QUSLJOB : ジョブのリスト

QUSLOBJ はジョブのリストをユーザー・スペース(*USESPC)に出力する API であるが

ここでは QUSLOBJ の使い方と同時に、ジョブの一覧の意味の解説もかねて

QUSLOBJ を紹介する目的がある。

パラメータ

必須パラメータ・グループ:

1. 修飾ユーザー・スペース名 入力 Char(20)
2. 形式名 入力 Char(8)
3. 修飾ジョブ名 入力 Char(26)
4. 状況 入力 Char(10)

 

任意パラメータ・グループ1:

5. エラー・コード 入出力 Char(*)

 

任意パラメータ・グループ2 :

6. ジョブ・タイプ 入力 Char(1)
7. 返されるフィールド数 入出力 Bynary(4)
8. 返されるフィールドのキー 入力 Bynary(4)の配列

QUSLJOB API は修飾ユーザー・スペース名 ( *USRSPC ) として指定されたユーザー・スペース,

例えば 「USLOBJ   QTEMP」に指定されたジョブの一覧のリストを出力する。

・修飾ジョブ名

ここで指定する修飾ジョブ名とは、

ジョブ名 : * ,*CURRENT, *ALL またはジョブ名
ユーザー名 : ユーザーは、指定された特殊権限を所有していない。
ジョブ番号 : *ALL またはジョブ番号

である。

つまり、あるユーザーのジョブ情報 ( ジョブ名+ユーザー名+ジョブ番号 ) を調べるには

*ALL + (ユーザー名) + *ALL のジョブ情報で QUSLJOB を使って検索することができる。

またジョブ名だけでも検索することができる。

ジョブを特定するにはジョブ番号まで含めて正確に特定しなければならないので

ジョブ番号の検索に QUSLJOB は役に立つAPIである。

・状況

*ACTIVE

 

・・・・・・

活動ジョブ。ただしここで言う活動ジョブとは WRKACTJOB として表示されている

ジョブだけでなく、グループ・ジョブ、システム要求ジョブや切断されたジョブも含まれている。

QUSLJOB API の使い方で最も注意しなければならないのは、この部分である。

異常終了したジョブを次のサインオンで復活させることができるのは、ご存じだと思うが

あの異常終了したジョブは WRKACTJOB では表示されることはないが、切断されたジョブとして

システム内部に残っている。

QUSLJOB では *ACTIVE を指定しても切断ジョブも一緒に一覧として出力されてしまうので

この点に注意が必要である。

切断ジョブの見分け方については次の API : QUSRJOBI で説明する。

*JOBQ ・・・・・・ 現在、ジョブ待ち行列にあるジョブ
*OUTQ ・・・・・・ 実行は完了したものの、その出力がまだ出力待ち行列にあるジョブ
*ALL ・・・・・・ 状況にかかわらず、すべてのジョブ

【 サンプル・ソース:TESTUSLJOB 】
0001.00 #include <stdio.h>                                                  
0002.00 #include <stdlib.h>                                                 
0003.00 #include <string.h>                                                 
0004.00 #include <QUSCRTUS.h>                                               
0005.00 #include <QUSLJOB.h>                                                
0006.00 #include <QUSRTVUS.h>                                               
0007.00 #include <micomput.h> /* triml */                                   
0008.00 #include <QMHRTVM.h>                                                
0009.00 #include <QMHSNDPM.h>                                               
0010.00                                                                     
0011.00 #define TRUE         0                                              
0012.00 #define FALSE       -1                                              
0013.00 typedef struct {                                                    
0014.00    int  BYTESPRO;                                                   
0015.00    int  BYTESAVL;                                                   
0016.00    char MSGID[7];                                                   
0017.00    char RESRVD;                                                     
0018.00    char EXCPDATA[100];                                              
0019.00 } ERRSTRUCTURE;       /* Define the error return structure      */  
0020.00 ERRSTRUCTURE  errcode;/* API Error Code Structure               */  
0021.00 typedef struct {                                                        
0022.00    char NM[10];                                                         
0023.00    char LIB[10];                                                        
0024.00 } QNAME;     /* Define the qualified name                            */ 
0025.00 QNAME         inname;                 /*  Qualified user space name */  
0026.00 typedef struct {                                                        
0027.00    char JOB[10];                                                        
0028.00    char USER[10];                                                       
0029.00    char JOBNBR[6];                                                      
0030.00 } JOBINFO;                                                              
0031.00 JOBINFO jobinfo;                                                        
0032.00 int  offset, size, entries;                                             
0033.00 typedef _Packed struct header_struct {                                  
0034.00      char user_data[64];                                                
0035.00      int  generic_header_size;                                          
0036.00      char header_version[4];                                            
0037.00      char format_name[8];                                               
0038.00      char program_name[10];                                             
0039.00      char time_generated[13];                                           
0040.00      char information_status;                                           
0041.00      int  usrspc_used;                                                  
0042.00      int  parm_section_offset;                                    
0043.00      int  parm_section_size;                                      
0044.00      int  header_section_offset;                                  
0045.00      int  header_section_size;                                    
0046.00      int  list_section_offset;                                    
0047.00      int  list_section_size;                                      
0048.00      int  number_of_entries;                                      
0049.00      int  size_of_entry;                                          
0050.00 } header_struct;                                                  
0051.00 header_struct inspace;                                            
0052.00 char ref[132];                                                    
0053.00                                                                   
0054.00 /*************************************************************/   
0055.00 /*       内 部 使 用  関  数                          */   
0056.00 /*************************************************************/   
0057.00 void  CreateUsrSpace(char* space, char* lib);                     
0058.00 void  ApiError(char* place);                                      
0059.00 void  SendMessage(char* Message, char* Status, char* Pgmque);     
0060.00                                                                   
0061.00 void main(void){                                                  
0062.00    int i;                                                         
0063.00    char Job[11], User[11], Nbr[7];                                      
0064.00    Qus_JOBL0100_t jobl0100;                                             
0065.00                                                                         
0066.00    printf("** TESTUSLJOB : QUSLJOB のテスト **n");                     
0067.00    getchar();                                                           
0068.00                                                                         
0069.00    /*(1) QUSCRTUS: ユーザー・スペースの作成 */                          
0070.00    CreateUsrSpace("USLJOB    ", "QTEMP     ");                          
0071.00                                                                         
0072.00    /*(2) QUSLJOB: ユーザー QTMHHTTP のジョブ一覧を出力する */           
0073.00    memcpy(jobinfo.JOB, "*ALL      ", 10);                               
0074.00    memcpy(jobinfo.USER, "QTMHHTTP  ", 10);                              
0075.00    memcpy(jobinfo.JOBNBR, "*ALL  ", 6);                                 
0076.00                                                                         
0077.00    QUSLJOB((char*)&inname, "JOBL0100", (char*)&jobinfo, "*ACTIVE   ",   
0078.00        &errcode);                                                       
0079.00    if(errcode.BYTESAVL != 0){/*APIERR*/                                 
0080.00          ApiError("MAIN-QUSLJOB"); exit(0);                             
0081.00    }/*APIERR*/                                                          
0082.00                                                                         
0083.00    /*(3) QUSRTVUS: ユーザー・スペースを読んで初期情報を取得する */      
0084.00    QUSRTVUS("USLJOB    QTEMP     ", 0x01,sizeof(inspace), &inspace,  
0085.00         (char*)&errcode);                                            
0086.00    if(errcode.BYTESAVL != 0){/*APIERR*/                              
0087.00        sprintf(ref, "QUSRTVUS-%d", __LINE__);                        
0088.00        ApiError(ref);                                                
0089.00        return;                                                       
0090.00    }/*APIERR*/                                                       
0091.00   offset  = inspace.list_section_offset +1;                          
0092.00   size    = inspace.size_of_entry;                                   
0093.00   entries = inspace.number_of_entries;                               
0094.00                                                                      
0095.00   /*(4) QUSRTVUS: ユーザー・スペースを LOOP して読み取る */          
0096.00   for(i = 0; i<inspace.number_of_entries; i++){/*for-loop*/          
0097.00     QUSRTVUS((char*)&inname, offset, size, (char*)&jobl0100,         
0098.00        (char*)&errcode);                                             
0099.00     /*--------------( 処理の開始 )-----------------*/                
0100.00     memcpy(Job, jobl0100.Job_Name_Used, 10);                         
0101.00     Job[10] = 0x00;                                                  
0102.00     memcpy(User, jobl0100.User_Name_Used, 10);                       
0103.00     User[10] = 0x00;                                                 
0104.00     memcpy(Nbr, jobl0100.Job_Number_Used, 6);                        
0105.00     Nbr[6] = 0x00;                                                      
0106.00     printf("[%d] Job = %10s, User = %10s, Nbr = %06sn",                
0107.00          i, Job, User, Nbr);                                            
0108.00     /*--------------( 処理の終了 )-----------------*/                   
0109.00     offset += inspace.size_of_entry;                                    
0110.00   }/*for-loop*/                                                         
0111.00   getchar();                                                            
0112.00                                                                         
0113.00                                                                         
0114.00 }                                                                       
0115.00 /*******************************************/                           
0116.00 void  CreateUsrSpace(char* space, char* lib)                            
0117.00 /*******************************************/                           
0118.00 {                                                                       
0119.00 char          extattrib[10];           /*  External attributes       */ 
0120.00 long int      initialsize;                                              
0121.00 char          initialvalue;                                             
0122.00 char          authority[10];                                            
0123.00 char          description[50];                                          
0124.00 char          replace[10];                                              
0125.00                                                                         
0126.00      memset(&inname, 0, sizeof(QNAME));                              
0127.00      memcpy(inname.NM, space, 10);                                   
0128.00      memcpy(inname.LIB, lib, 10);                                    
0129.00      initialsize = 1000;                                             
0130.00      initialvalue = '0';                                             
0131.00      memcpy(authority, "*ALL      ", sizeof(authority));             
0132.00      memset(description, ' ', sizeof(description));                  
0133.00      memcpy(replace, "*YES      ", sizeof(replace));                 
0134.00      memcpy(extattrib, "PF        ", sizeof(extattrib));             
0135.00      QUSCRTUS((char *)(&inname), extattrib, initialsize,             
0136.00               &initialvalue, authority, description, replace,        
0137.00              (char *)(&errcode));/* create user space at QTEMP )*/   
0138.00 }                                                                    
0139.00 /**************************/                                         
0140.00 void  ApiError(char* place)                                          
0141.00 /**************************/                                         
0142.00 {                                                                    
0143.00    char msgid[8], msgdta[100], Message[512], msg[512];               
0144.00    int  msglen, msgdtalen, pos;                                      
0145.00    char* ptr;                                                        
0146.00    typedef struct {                                                  
0147.00      Qmh_Rtvm_RTVM0100_t  rtvm0100;                                     
0148.00      char msg[512];                                                     
0149.00    } ERRMSG;                                                            
0150.00    ERRMSG errmsg;                                                       
0151.00                                                                         
0152.00    memset(msgid, 0, sizeof(msgid));                                     
0153.00    memcpy(msgid, errcode.MSGID, 7);                                     
0154.00    memset(msgdta, 0, sizeof(msgdta));                                   
0155.00    memcpy(msgdta, errcode.EXCPDATA, 100);                               
0156.00    msglen = sizeof(Qmh_Rtvm_RTVM0100_t);                                
0157.00    msgdtalen = strlen(msgdta);                                          
0158.00    memset(&errmsg, 0, sizeof(ERRMSG));                                  
0159.00    QMHRTVM(&errmsg,  msglen, "RTVM0100", msgid, "QCPFMSG   *LIBL     ", 
0160.00           msgdta, msgdtalen, "*YES      ", "*YES      ", &errcode);     
0161.00    memset(Message, 0, sizeof(Message));                                 
0162.00    memcpy(Message, errmsg.msg, 512);                                    
0163.00    ptr = strstr(Message, "&N");                                         
0164.00    if(ptr != NULL){                                                     
0165.00      pos = (int)(ptr - Message);                                        
0166.00      Message[pos] = 0x00;                                               
0167.00    }                                                                    
0168.00    sprintf(msg, "%s-%s:%s", place, msgid, Message);                  
0169.00    SendMessage(msg, "*COMP     ", "*PGMBDY   ");                     
0170.00 }                                                                    
0171.00 /**********************************************************/         
0172.00 void SendMessage(char* Message, char* Status, char* Pgmque)          
0173.00 /**********************************************************/         
0174.00 {                                                                    
0175.00   char msg_id[7];                                                    
0176.00   char msg_fl_name[20];                                              
0177.00   char msg_data[3000];                                               
0178.00   int msg_data_len;                                                  
0179.00   char msg_type[10];                                                 
0180.00    int  pgm_stk_cnt;                                                 
0181.00   char msg_key[4];                                                   
0182.00    char pgm_que[10];                                                 
0183.00                                                                      
0184.00     memset(msg_id, 0, sizeof(msg_id));                               
0185.00     strcpy(msg_id, "CPF9897");                                       
0186.00     memset(msg_fl_name, 0, sizeof(msg_fl_name));                     
0187.00     strcpy(msg_fl_name, "QCPFMSG   QSYS      ");                     
0188.00     memset(msg_data, 0, sizeof(msg_data));                           
0189.00     strcpy(msg_data, Message);                                       
0190.00     msg_data_len = triml(Message, ' ');                              
0191.00     strcpy(msg_type, Status);                                        
0192.00     strcpy(pgm_que, Pgmque);                                         
0193.00     if(strncmp(Pgmque, "*EXT      ", 10) == 0)                       
0194.00       pgm_stk_cnt = 0;                                               
0195.00     else pgm_stk_cnt = 1;                                            
0196.00     memset(msg_key, 0x40, sizeof(msg_key));                          
0197.00     errcode.BYTESPRO = 160;                                          
0198.00     errcode.BYTESAVL = 0;                                            
0199.00     QMHSNDPM(msg_id, msg_fl_name, msg_data, msg_data_len, msg_type,  
0200.00          pgm_que, pgm_stk_cnt, msg_key, &errcode);                   
0201.00 }
【解説】

最初に CreateUsrSpace 関数で QUSCRTUS API を使って QTEMP/USLJOB *USRSPC を作成しておく。

次に QUSLJOB API によって

0073.00    memcpy(jobinfo.JOB, "*ALL      ", 10);                               
0074.00    memcpy(jobinfo.USER, "QTMHHTTP  ", 10);                              
0075.00    memcpy(jobinfo.JOBNBR, "*ALL  ", 6);                                 
0076.00                                                                         
0077.00    QUSLJOB((char*)&inname, "JOBL0100", (char*)&jobinfo, "*ACTIVE   ",   
0078.00        &errcode); 

のようにしてユーザー QTMHHTTP のジョブをユーザー・スペース QTEMP/USLJOB に出力する。

ただし出力されたジョブは活動中のジョブだけでなく異常終了したジョブも含まれている場合が

ある。

異常終了したジョブの見分け方は次のAPI : QUSRJOBI で解説することとする。

【実行結果】