Nous avons vu dans le premier article sur le PCML, que la gestion de l’usage des paramètres ne peut se faire dans le source d’un programme. On peut au mieux déclarer les paramètres en entrée, par le mot clé « const ».
Tous les autres paramètres seront déclarés en entrée/sortie dans le PCML.
Lors de déploiements de web service par script, il faut pouvoir gérer ces paramètres, de façon à générer des WSDL (SOAP) ou des SWAGGER (REST) corrects.
Cet article recense plusieurs méthodes possibles pour cette gestion.
PCML généré dans l’IFS – ajustement manuel :
Prérequis : génération du PCML dans l’IFS, options de compilation PGMINFO et INFOSTMF à renseigner.
On peut éditer le fichier et le modifier manuellement.
Il faudra faire attention à bien respecter le formalisme du PCML.
Avantages :
- Mise en œuvre minimaliste.
Inconvénients :
- Il faut penser après génération du PCML à le modifier, risque d’oubli comme pour toutes procédures peu usitées.
- Risque d’écraser le PCML modifié par le PCML standard lors d’une prochaine compilation.
- Risque d’erreur dans la modification, rendant inopérant le PCML.
- Ce n’est pas sport !
Cette méthode peut être utilisée si vous n’exposez que peu de web service, contenant que quelques paramètres. Même si nous la déconseillons fortement.
PCML généré dans l’IFS – ajustement programmatique :
Prérequis : génération du PCML dans l’IFS, options de compilation PGMINFO et INFOSTMF à renseigner.
Plutôt que d’éditer un PCML dans l’IFS, on peut prévoir de le modifier par programme, en se basant sur un formalisme de nommage des paramètres.
Par exemple, en suffixant le paramètre en entrée par « _I » et les paramètres en sortie par « _O ». Les paramètres en entrée/sortie n’auront pas besoin de suffixe, leurs usages dans le PCML est déjà correct.
Le programme devra mettre à jour le PCML dans l’IFS, en transformant l’usage des paramètres selon le suffixe.
Pour exemple, dans l’extrait de code ci-dessous, nous utilisons les API « C » pour modifier le PCML :
Si vous le souhaitez, nous pouvons sur demande fournir le code complet.
// Ouverture du fichier en mise à jour
fd = OpenFile(Path : O_RDWR + O_TEXTDATA + O_CCSID : S_IRGRP : 37 ) ;
if (fd < 0) ;
// fichier non ouvert : non trouvé ou vérouillé ou ...
// gestion personnalisée à faire
*inlr = *on ;
return ;
endif ;
// Boucle de lecture infinie - sortie explicite via le leave
// lecture du fichier totale, avec recherche de chaîne
Pos = 0 ;
dow (1 = 1) ;
// récupération de la longueur du fichier entre la position actuelle
// et la fin de fichier au premier passage, longueur totale du PCML
Length = ReadFile(fd:%addr(Data):%size(Data)) ;
// Longueur à 0 --> fin de fichier on sort de la boucle
if (Length = 0);
leave;
else;
// Recherche du tag de déclaration d'un paramètre
// on récupère sa position
Debut = %scan('<data name="' : Data) ;
if Debut > 0;
// Extraction de la position du suffixe
// En fin de nom paramètre sur 2
Debut += 12 ; // longueur chaîne '<data name="'
DebSuf = %scan('"' : Data : Debut) - 2;
// Extraction de la position de l'usage du paramètre
DebUsage = %scan('usage="' : Data : Debut) + 6; // + lng'usage="'
// détermination de l'usage en fonction du suffixe
select;
when %scan('_I' : Data : DebSuf : 2) > 0;
UsageIO = 'input" />' ;
when %scan('_O' : Data : DebSuf : 2) > 0;
UsageIO = 'output" />' ;
other;
UsageIO = 'inputoutput" />' ;
endsl;
// positionnement sur l'adresse de début de modification
Pos += DebUsage;
Data = UsageIO ;
lseek(fd: Pos: SEEK_SET) ;
// modification du fichier
WriteOK = write(fd:%addr(data): 15) ;
Pos += 15 ;
endif;
endif;
enddo;
PCML issu de la compilation :
<pcml version="6.0">
<!-- RPG program: TESTWS -->
<!-- created: 2018-03-12-11.09.56 -->
<!-- source: DT/QRPGLESRC(TESTWS) -->
<!-- 3 -->
<program name="TESTWS" path="/QSYS.LIB/DT.LIB/TESTWS.PGM">
<data name="VARIN_I" type="char" length="15" usage="inputoutput" />
<data name="VAROUT_O" type="char" length="30" usage="inputoutput" />
</program>
</pcml>
PCML après traitement par le PGM :
<pcml version="6.0">
<!-- RPG program: TESTWS -->
<!-- created: 2018-03-12-11.09.56 -->
<!-- source: DT/QRPGLESRC(TESTWS) -->
<!-- 3 -->
<program name="TESTWS" path="/QSYS.LIB/DT.LIB/TESTWS.PGM">
<data name="VARIN_I" type="char" length="15" usage="input" />
<data name="VAROUT_O" type="char" length="30" usage="output" />
</program>
</pcml>
Avantages :
- Automatisation possible, à la création du web service, en masse sur un répertoire de l’IFS, … Au gré des besoins !
- Si vous avez l’utilité du PCML pour d’autres applications que l’exposition des web services, vous pouvez par ce biais ne gérer qu’une fois cette problématique.
Inconvénients :
- Risque d’oubli de génération du PCML dans l’IFS.
- Risque d’écraser le PCML modifié par le PCML standard lors d’une prochaine compilation.
- Risque de conflit entre les normes de nommage, ou de non utilisation de la norme.
- Si vous avez plusieurs partitions, il faudra soit déployer le PCML dans l’IFS de chaque partition, soit le générer dans l’IFS puis le modifier via le programme.
Extraction des informations du PCML d’un objet :
Prérequis : génération du PCML dans l’objet, les options de compilation peuvent être dans le source.
Cette méthode consiste à :
- Extraire les informations du PCML, via l’API QBNRPII. Les informations relatives aux paramètres seront stockés dans fichier.
- Gérer l’usage des paramètres trouvés, par un interactif.
- Générer le paramètre -parameterUsage à ajouter à la commande shell de création de web service.
Programme d’extraction des informations PCML :
**free
/if defined(*crtbndrpg)
ctl-opt actgrp(*NEW) ;
/endif
ctl-opt option(*NODEBUGIO : *SRCSTMT);
//-------------------------------------------------------------------------------------------------/
// Paramètre PGM
Dcl-Pi *N;
P_Objet Char(10) const;
P_Lib Char(10) const;
P_Type Char(10) const;
P_Error Char(110);
End-Pi;
//-------------------------------------------------------------------------------------------------/
// DS objet et module pour appel APi
dcl-ds qualname qualified based(TypeDef);
Obj Char(10);
Lib Char(10);
end-ds;
dcl-ds Qbn_Interface_Entry_t qualified based(TypeDef);
// Offset from start of receiver
Offset_Next_Entry int(10) ;
Module_Name Char(10) ;
Module_Library Char(10) ;
Interface_Info_CCSID int(10) ;
Interface_Info_Type int(10) ;
Offset_Interface_Info int(10) ;
Interface_Info_Length_Ret int(10) ;
Interface_Info_Length_Avail int(10) ;
end-ds;
dcl-ds Qbn_PGII0100_t qualified based(TypeDef);
Bytes_Returned int(10) ;
Bytes_Available int(10) ;
Obj_Name Char(10) ;
Obj_Lib_Name Char(10) ;
Obj_Type Char(10) ;
Reserved3 Char(2) ;
Offset_First_Entry int(10) ;
Number_Entries int(10) ;
end-ds;
dcl-ds errcode qualified;
bytesprov int(10) inz(0);
bytesavail int(10) ;
end-ds;
dcl-ds psds psds ;
codmsg char(7) pos(40);
Libmsg char(100) pos(91);
end-ds;
// Define the initial storage for the first call to the API
dcl-ds tempRcvr likeds(Qbn_PGII0100_t);
dcl-ds rcvr likeds(Qbn_PGII0100_t) based(pRcvr);
dcl-ds entry likeds(Qbn_Interface_Entry_t) based(pEntry);
dcl-ds NomObj likeds(qualname);
dcl-ds NomMod likeds(qualname);
//-------------------------------------------------------------------------------------------------/
// Constantes
dcl-c AllMod '*ALLBNDMOD' ;
dcl-c LibModPGM 'QTEMP' ;
dcl-c Format_retour 'RPII0100' ;
// tailleXml doit avoir la même valeur que la variable XMLVALUE
dcl-c tailleXml 8192 ;
//-------------------------------------------------------------------------------------------------/
// Variables
dcl-s pRcvr pointer inz(*null);
dcl-s data Char(tailleXml) based(pData);
dcl-s pcml Varchar(tailleXml);
dcl-s len int(10);
dcl-s i int(10);
dcl-s entry_off int(10);
//-------------------------------------------------------------------------------------------------/
// Prototype d'appel de l'API QBNRPII (Retrieve Program Interface Information)
dcl-pr QBNRPII extpgm('QBNRPII') ;
Receiver_variable likeds(Qbn_PGII0100_t);
Length_of_receiver_variable int(10) const;
Format_name Char(8) const;
Qualified_object_name likeds(qualname) const;
Object_Type Char(10) const ;
Qualified_bound_module_name likeds(qualname) const;
Error_code likeds(errcode);
end-pr;
// Prototype d'initialisation SQL
dcl-pr initSQL end-pr;
// Prototype déallocation mémoire
dcl-pr cleanup end-pr;
// Prototype extraction paramètre
dcl-pr rtvparam ind end-pr;
//-------------------------------------------------------------------------------------------------/
initSQL();
// Construction des DS objet et module pour l'appel de l'API
NomObj.Obj = P_Objet ;
NomObj.Lib = P_Lib ;
if P_Type = '*PGM' ;
// Dans le cas d'un programme, nom module = nom PGM et bib = QTEMP
NomMod.Obj = P_Objet ;
NomMod.Lib = LibModPGM ;
else;
// Dans le cas d'un programme de service, appel de l'API pour tous les modules
NomMod.Obj = AllMod ;
NomMod.Lib = *blanks ;
endif;
// Appel de l'API - détermination de la taille du retour contenant l'ensemble des PCML
callp(e) QBNRPII (tempRcvr : %size(tempRcvr) : Format_retour : NomObj : P_Type : NomMod : errcode);
// Non trouvé : objet ou programme ou bibliothèque
if %error;
P_Error = codmsg + ' - ' + libmsg ;
cleanup() ;
return;
endif;
// Pas de PCML
if tempRcvr.Bytes_Available <= tempRcvr.Bytes_Returned;
P_Error = 'Aucun PCML trouvé dans l''objet ' + P_Objet + ' de la bibliothèque ' + P_Lib ;
cleanup() ;
return;
endif;
pRcvr = %alloc(tempRcvr.Bytes_Available);
callp(e) QBNRPII (rcvr : tempRcvr.Bytes_Available : Format_retour : NomObj : P_Type : NomMod : errcode);
// Normalement, aucune erreur à ce niveau, mais par sécurité on refait les tests
if %error or rcvr.Number_Entries = 0 ;
if codmsg = *blanks ;
P_Error = 'Erreur API - aucune donnée retournée';
else;
P_Error = codmsg + ' - ' + libmsg ;
endif;
cleanup();
return;
endif;
// Lecture de la variable retour par PCML
// --> Pour les *PGM, un seul PCML, pour les *SRVPGM, autant de PCML que de modules
entry_off = rcvr.offset_First_Entry;
for i = 1 to rcvr.Number_Entries;
pEntry = pRcvr + entry_off;
entry_off = entry.Offset_Next_Entry;
pData = pRcvr + entry.Offset_Interface_Info;
len = entry.Interface_Info_Length_Ret;
// Si le PCML récupéré est plus grand que la taille de la variable prévue --> erreur
if len > tailleXml ;
P_Error = 'Taille PCML : ' + %char(len) + ' trop grande pour la variable retour : ' + %editc(tailleXml : 'X') ;
cleanup() ;
return;
endif;
pcml = %subst(data : 1: len);
if not rtvparam() ;
return;
endif;
endfor;
cleanup();
P_Error = *blanks ;
return;
//----------------------------------------------------------------------------------------//
// Procédure d'initialisation SQL //
//----------------------------------------------------------------------------------------//
dcl-Proc initSQL;
Dcl-Pi *n end-Pi;
// initialisation des options de compilation sql
EXEC SQL
Set Option
Naming = *Sys,
Commit = *None,
UsrPrf = *User,
DynUsrPrf = *User,
Datfmt = *iso,
CloSqlCsr = *EndMod;
// création de la table de travail dans QTEMP, ou remise à blanc si elle existe déjà
EXEC SQL
create or replace table qtemp.wsparam
(PROCNAME varchar(128),
ENTRPT varchar(128),
PARNAME varchar(128),
USAGEIO varchar(11))
on replace delete rows;
end-proc;
//----------------------------------------------------------------------------------------//
// Procédure de désallocation de la mémoire //
//----------------------------------------------------------------------------------------//
dcl-Proc Cleanup;
Dcl-Pi *n end-Pi;
if pRcvr <> *null and pRcvr <> %addr(tempRcvr);
dealloc(n) pRcvr;
endif;
end-proc;
//----------------------------------------------------------------------------------------//
// Procédure d'extraction des paramètres //
//----------------------------------------------------------------------------------------//
dcl-Proc rtvparam;
Dcl-Pi *n ind end-Pi;
dcl-s XMLVALUE sqltype(XML_CLOB : 8192);
// conversion du texte PCML en un champs XML
EXEC SQL
set :XMLVALUE = xmlparse(document :pcml) ;
if sqlcode <> 0 ;
P_Error = 'Erreur de conversion XML, SQLCODE = ' + %char(sqlcode);
cleanup() ;
return *off;
endif;
// Extraction du XML du nom du module, du nom de point d'entrée, du nom des paramètres et de leur usage,
// dans une table temporaire de QTEMP
EXEC SQL
insert into qtemp.wsparam select x.* from
xmltable('$d/pcml/program/data' passing :XMLVALUE
as "d"
columns PROCNAME varchar(128) path '../@name',
ENTRPT varchar(128) path '../@entrypoint',
PARNAME varchar(128) path '@name',
USAGEIO varchar(11) path '@usage') as X ;
if sqlcode <> 0 ;
P_Error = 'Erreur insertion WSPARAM, SQLCODE = ' + %char(sqlcode);
cleanup() ;
return *off;
endif;
return *on ;
END-PROC;
A partir du fichier généré, vous pouvez gérer l’usage des paramètres :


Il ne reste plus qu’à créer le paramètre de la commande shell.
Extrait de code de la génération du paramètre -parameterUsage :
formalisme : -parameterUsage PROC1:i,o:PROC2:i,i,io
Attention à la casse des points d’entrée (PROC1 / PROC2…).
dcl-Proc gener_Opt;
Dcl-Pi *n end-Pi;
Dcl-s LProc char(128);
Dcl-s LEntrpt char(128);
Dcl-s LParam char(128);
Dcl-s LProcSh char(128);
Dcl-s LUsage char(11);
Dcl-s LProcSV char(30) inz(*blanks);
Dcl-s param1 ind;
//------------------------------------//
// Constantes
dcl-c Deb_Opt '-parameterUsage ';
dcl-c SRVPGM '*SRVPGM' ;
//------------------------------------//
// Création d'un curseur récupérant les données du fichier de travail QTEMP/WSPARAM
EXEC SQL
declare curs02 cursor for
SELECT PROCNAME, ENTRPT, PARNAME, USAGEIO
FROM WSPARAM;
EXEC SQL
open curs02;
// Lecture du fichier WSPARAM, pour alimentation de la variable retour
dou sqlcode <> 0;
EXEC SQL
fetch from curs02
into :LProc, :LEntrpt, :LParam, :LUsage;
if sqlcode = 0;
//Entête module
if LProc <> LProcSV ;
// détermination du nom de la procédure pour la commande Shell (casse sensitive)
if P_Type = SRVPGM ;
LProcSh = LEntrpt ;
else ;
LProcSh = LProc ;
endif;
// Insertion du nom de la procédure dans la commande
if LProcSV = *blanks;
P_Opt = Deb_Opt + %trim(LProcSh) +':'; // initialisation commande - 1ière proc
else;
P_Opt = %trim(P_Opt) + ':' + %trim(LProcSh) +':'; // Ajout 2ième procédure et suivan
endif;
LProcSV = LProc;
param1 = *on ;
endif;
//détail paramètre - construction de l'usage des paramètres
if param1 ;
param1 = *off ;
else;
P_Opt = %trim(P_Opt) + ',';
endif;
select ;
when LUsage = Input;
P_Opt = %trim(P_Opt) + 'i';
when LUsage = Output;
P_Opt = %trim(P_Opt) + 'o';
other;
P_Opt = %trim(P_Opt) + 'io';
endsl;
endif;
enddo;
EXEC SQL
close curs02;
end-proc;
Dans le cas de web service de type REST, il faudra alimenter le fichier de propriété avec les bons usages des paramètres au lieu de construire le paramètre -parameterUsage.
Avantages :
- Gestion de l’usage des paramètres au déploiement du web service.
- Intégration simple au scénario de déploiement de web service ou autre traitement si besoin.
- Dans le cas de sauvegarde du script de déploiement, il est directement utilisable sur une autre partition.
Inconvénients :
- Aucun lorsqu’on a le source à disposition !
Cette dernière méthode sera intégrée à la prochaine version de notre outils WEBCONSOLE.
Retrouvez-nous à l’université du i les 16 et 17 mai.
Optimisez vos temps de sauvegardes et de restaurations à moindre frais
Vous voulez faire un point sur vos opérations de sauvegardes, voici quelques points à regarder ?
1) Vérifiez vos niveaux logiciels :
Assurez-vous d’avoir un bon niveau de PTF pour le groupe SF99724
Vous ne devez pas avoir plus de 6 mois de retard , vérifier sur le site IBM FIX CENTRAL
2) Vérifiez vos supports :
Assurez-vous que vos bandes ne sont pas trop vieilles, trois ans c’est le maximum pour du LTO.
Ça peut dégrader les performances, mais aussi et surtout, rendre impossible partiellement une restauration.
Vous pouvez avoir des informations sur vos supports dans le menu SST :
9. Work with save storage and restore storage
Ou en faisant un PRTERRLOG
Exemple :
PRTERRLOG TYPE(*VOLSTAT) VOLTYPE(3580)
Remarque: l’option de cette commande ne peut être mise en base de données.
3) Faites le ménage :
Attention à tous les objets obsolètes, les duplications, les SAVF.
J’ai fait enlever 27 gigas chez un client …
Et surtout attention à l’IFS ou la gestion est souvent anarchique .
Pour vous aider vous pouvez utiliser des outils comme RTVDSKINF, pour suivre l’évolution de vos espaces
4) Vérifiez vos scripts :
Assurez-vous que vos commandes d’initialisation utilisent le maximum de compactage de vos supports, on trouve souvent des commandes qui date du dérouleur précédent
Le meilleur compromis est pour l’initialisation
==> INZTAP … DENSITY(*DEVTYPE)
et pour les commandes de sauvegarde
==> SAVLIB COMPACT(*DEV)
Supprimez les dlyjob notamment sur les arrêts de TCP/IP qui ne servent plus, 300 secondes c’est 10 minutes , j’ai vu 30 minutes de DLY dans un script CL.
Le temps de sauvegarde de l’ifs prend de plus en plus de temps notamment si vous avez beaucoup de petits fichiers.
Une option apparue par PTF en 6.1 et disponible depuis les autres versions permet de diminuer ce temps :
==> SAV … ASYNCBRING(*YES)
Le plus simple pour tester, modifier la valeur par défaut de la commande SAV
==> CHGCMDDFT CMD(SAV) NEWDFT(‘ASYNCBRING(*YES)’)
Prenez les temps avant et après, vérifiez le gain…
S’il n’y a pas de gain, probablement que votre machine n’a pas de mémoire, vous pouvez faire retours en arrière.
==> CHGCMDDFT CMD(SAV) NEWDFT(‘ASYNCBRING(*NO)’)
Sauvegardez les droits privés :
==> SAVLIB … PVTAUT(*YES)
Cela évitera une opération de RSTAUT.
5) Testez vos sauvegardes :
Par exemple, restaurez un objet en fin de bande, ce qui vous garantira l’intégrité complète de votre sauvegarde.
6) A ne pas faire :
Pour gagner du temps en sauvegarde, ne pas sauvegarder les indexes.
Le gain de temps sera largement perdu à la restauration.
7) A étudier
La sauvegarde des spools
==>SAVLIB SPLFDTA(*all)
Si vous n’avez pas besoin de vos spools ne les sauvegardez pas
Si vous utilisez cette option, assurez-vous de ne pas avoir de spool obsolètes , faites une épuration avant vos sauvegardes, J’ai vu 237000 spools sauvegardés inutilement…
Si vous devez utiliser du cryptage, choisissez du cryptage matériel fourni en standard sur les LTO.
Sauvegarde en While Active
Allonge considérablement les temps de sauvegarde, ne doit être utilisé qu’en cas d’arrêt impossible de la production
Découpez les sauvegardes
Attention à bien maitriser l’ensembles des supports et la procédure pour les restaurations
8 ) Conclusion
Il est possible qu’en ayant étudié tous ces points, vous ne puissiez pas optimiser mieux vos phases d’immobilisations, c’est que votre système est bien géré ou que vous allez devoir en changer !
La GDPR c’est le 25 mai, où en êtes vous avec votre IBM i ?
Le but n’est pas ici de développer toutes les spécificités de la GDPR, par exemple, pour la gestion de vos registres de traitement vous n’échapperez pas à l’analyse de votre SI et sans doute vous aurez besoin d’une aide juridique si vous gérez des données sensibles ou confidentielles.
Mais l’idée est de voir comment votre IBM i peut vous aider techniquement à réaliser les obligations de la nouvelle loi.
Voici une liste de points à vérifier .
1) Identifier les personnes (pour que quelqu’un puisse faire quelque chose il lui faut un profil et un mot de passe …).
3 conseils :
Passez vos accès SSH (pour que les MDP ne circulent pas en clair)
Appliquez à votre IBM i la même politique de changement de Password que dans le reste votre entreprise, en attendant un single sinon.
2) Ajuster les droits des utilisateurs, en théorie une personne ne doit pas avoir plus de droits que ce que lui impose ses tâches .
3 conseils :
Analysez les droits sur les ressources avec authority collection
Analysez les partages de L’IFS.
Et après mettez en place une politique plus restrictive, attention aux effets de bord
3) Pour la tracabilité, les journaux d’audit propose un grand nombre d’informations
4 conseils :
Ajoutez des triggers after sur certaines tables pour loguer *
Ajoutez des programmes d’exit sur les traitements (ODBC, FTP, PARTAGE, SQL)
En cas de violation agissez …
* Ce point peut être mis en place à l’aide des tables temporelles, bien meilleur, mais plus compliqué à mettre en place. Par contre pour vos nouveaux traitements, pensez y !
4) Anonymisation et cryptage des données, vous pouvez crypter vos données dans l’ASP, dans vos sauvegardes par BRMS, et par SQL sur vos bases de données RCAC et Field Proc.
3 Conseils :
Attention à la gestion de la pseudonimisation pour les data Whare house.
Testez vos restaurations !
5) Registre de traitements.
Il vous faudra avoir une base de donnée centralisée, elle peut être sur votre ibm i …
Sauvegarde restauration d’un serveur de webservices
Sauvegarde et Restauration des webservers
Pour Sauvegarder et Restaurer un server de webservices vous pouvez utiliser les scriptes QSH prévus à cet effet.
Sauvegarde
saveWebServicesServer.sh
-server ‘server’
-saveFile ‘savf’ (‘/qsys.lib/libsavf.lib/savf.file’)
Restauration
restoreWebServicesServer.sh
-fromServerDirectory ‘server-directory’ (‘/www/server’)
-saveFile ‘savf’ (‘/qsys.lib/libsavf.lib/savf.file’)
Remarque :
Le seul support est le SAVF
Mais comment restaurer un serveur de webservices, si vous n’avez que les répertoires de l’IFS.
Il faut savoir qu’un webserveur de webservices c’est 3 choses :
– des répertoires de configuration (dans /www/)
– une instance APACHE déclarée dans http server (fichier QATMHINSTC qui contient un membre pour chacun instance)
– un enregistrement dans LWI ou Liberty.
Il vous faudra donc respecter les étapes suivantes
1) Restauration des répertoires de L’IFS
OBJ((‘/www/YOURSERVER’))
Vous pouvez restaurer l’IFS à partir d’autres supports…
2) Autorisation de la branche du server au profil QTMHHTTP
Le profil QTMHHTTP est le profil utilisé par http server pour la plupart de ses opérations. Il doit avoir un droit explicite sur ces fichiers.
USER(QTMHHTTP)
DTAAUT(*RWX)
OBJAUT(*ALL)
SUBTREE(*ALL)
Remarque :
Cette étape peut être facultative si vous avez une sauvegarde avec les droits privées paramètres PVTAUT(*YES) de vos commandes SAVXXX.
Il vous faudra préciser dans la commande RST … le paramètre PVTAUT(*YES)
3) Création du membre de l’instance APACHE dans le fichier QATMHINSTC de QUSRSYS.
En utilisant la commande
wrkmbrpdm qusrsys/QATMHINSTC
Dupliquer un membre existant en lui donnant le nom de votre server YOURSERVER
puis modifier le contenu en lui indiquant le nom de votre serveur
-apache -d /www/YOURSERVER -f conf/httpd.conf
Cette modification peut-être faite, via l’option 18, par SQL, par script…
4) Enregistrement de votre serveur dans liberty ou LWI
Sous LWI
java -cp /QIBM/ProdData/OS400/jt400/lib/jt400Native.jar:/QIBM/ProdData/OS/OSGi/LWI81/native/iasadmin.jar com.ibm.lwi.admin.IntegratedServerAdmin -registerServer YOURSERVER /www
Remarque :
La version de votre lwi ici 8.1, dépend de votre système pour la connaitre :
Se mettre sous qsh
cd /QIBM/ProdData/OS/OSGi
puis ls
o
par exemple ici la version est 6.0
donc la commande devient
java -cp /QIBM/ProdData/OS400/jt400/lib/jt400Native.jar:/QIBM/ProdData/OS/OSGi/LWI60/native/iasadmin.jar com.ibm.lwi.admin.IntegratedServerAdmin -registerServer YOURSERVER /www
Sous Liberty
java -cp /QIBM/ProdData/OS400/jt400/lib/jt400Native.jar:/QIBM/ProdData/OS/OSGi/shared/lib/iasadmin.jar com.ibm.lwi.admin.IntegratedServerAdmin -registerServer YOURSERVER /www
Vous avez un fichier de propriétés, il est dans le répertoire LWI correspondant :
Votre serveur est opérationnel et vous pouvez l’utiliser à nouveau.
Les fichiers de référence des serveurs enregistrés se trouvent :
En 6.1, dans /QIBM/UserData/OS/OSGi/registry/registry.data pour Lwi
À partir de la 7.1, dans /QIBM/UserData/OS/OSGi/registry/iasregistry.data pour Liberty
Vous pouvez désormais arrêter et redémarrer votre serveur.
ENDTCPSVR *HTTP HTTPSVR(YOURSERVER)
STRTCPSVR *HTTP HTTPSVR(YOURSERVER)
Exemple de requêtes SQL pour retrouver des informations
Liste des instances apaches démarrées
SELECT DISTINCT SERVER_TYPE
FROM TABLE(QSYS2.ACTIVE_JOB_INFO(
SUBSYSTEM_LIST_FILTER => ‘QHTTPSVR’)) X_table
WHERE function = ‘QZSRHTTP’
Liste des instances HTTP déclarées
SELECT TABLE_PARTITION as MEMBER FROM SYSPARTITIONSTAT
WHERE TABLE_NAME = ‘QATMHINSTC’ AND TABLE_SCHEMA = ‘QUSRSYS’
Remarque :
Admin n’a pas d’instance dans ce fichier
La jonction entre les tables pour voir celles qui ne sont pas démarrées
SELECT DISTINCT SERVER_TYPE, TABLE_PARTITION
FROM SYSPARTITIONSTAT a
Join TABLE(QSYS2.ACTIVE_JOB_INFO(
SUBSYSTEM_LIST_FILTER => ‘QHTTPSVR’)) B
on B.server_type = ‘QIBM_HTTP_’ concat TABLE_PARTITION
and TABLE_NAME = ‘QATMHINSTC’
AND TABLE_SCHEMA = ‘QUSRSYS’
where function = ‘QZSRHTTP’
PCML : Gérer l’usage des paramètres lors déploiements de web service par script
Nous avons vu dans le premier article sur le PCML, que la gestion de l’usage des paramètres ne peut se faire dans le source d’un programme. On peut au mieux déclarer les paramètres en entrée, par le mot clé « const ».
Tous les autres paramètres seront déclarés en entrée/sortie dans le PCML.
Lors de déploiements de web service par script, il faut pouvoir gérer ces paramètres, de façon à générer des WSDL (SOAP) ou des SWAGGER (REST) corrects.
Cet article recense plusieurs méthodes possibles pour cette gestion.
PCML généré dans l’IFS – ajustement manuel :
Prérequis : génération du PCML dans l’IFS, options de compilation PGMINFO et INFOSTMF à renseigner.
On peut éditer le fichier et le modifier manuellement.
Il faudra faire attention à bien respecter le formalisme du PCML.
Avantages :
Inconvénients :
Cette méthode peut être utilisée si vous n’exposez que peu de web service, contenant que quelques paramètres. Même si nous la déconseillons fortement.
PCML généré dans l’IFS – ajustement programmatique :
Prérequis : génération du PCML dans l’IFS, options de compilation PGMINFO et INFOSTMF à renseigner.
Plutôt que d’éditer un PCML dans l’IFS, on peut prévoir de le modifier par programme, en se basant sur un formalisme de nommage des paramètres.
Par exemple, en suffixant le paramètre en entrée par « _I » et les paramètres en sortie par « _O ». Les paramètres en entrée/sortie n’auront pas besoin de suffixe, leurs usages dans le PCML est déjà correct.
Le programme devra mettre à jour le PCML dans l’IFS, en transformant l’usage des paramètres selon le suffixe.
Pour exemple, dans l’extrait de code ci-dessous, nous utilisons les API « C » pour modifier le PCML :
Si vous le souhaitez, nous pouvons sur demande fournir le code complet.
// Ouverture du fichier en mise à jour fd = OpenFile(Path : O_RDWR + O_TEXTDATA + O_CCSID : S_IRGRP : 37 ) ; if (fd < 0) ; // fichier non ouvert : non trouvé ou vérouillé ou ... // gestion personnalisée à faire *inlr = *on ; return ; endif ; // Boucle de lecture infinie - sortie explicite via le leave // lecture du fichier totale, avec recherche de chaîne Pos = 0 ; dow (1 = 1) ; // récupération de la longueur du fichier entre la position actuelle // et la fin de fichier au premier passage, longueur totale du PCML Length = ReadFile(fd:%addr(Data):%size(Data)) ; // Longueur à 0 --> fin de fichier on sort de la boucle if (Length = 0); leave; else; // Recherche du tag de déclaration d'un paramètre // on récupère sa position Debut = %scan('<data name="' : Data) ; if Debut > 0; // Extraction de la position du suffixe // En fin de nom paramètre sur 2 Debut += 12 ; // longueur chaîne '<data name="' DebSuf = %scan('"' : Data : Debut) - 2; // Extraction de la position de l'usage du paramètre DebUsage = %scan('usage="' : Data : Debut) + 6; // + lng'usage="' // détermination de l'usage en fonction du suffixe select; when %scan('_I' : Data : DebSuf : 2) > 0; UsageIO = 'input" />' ; when %scan('_O' : Data : DebSuf : 2) > 0; UsageIO = 'output" />' ; other; UsageIO = 'inputoutput" />' ; endsl; // positionnement sur l'adresse de début de modification Pos += DebUsage; Data = UsageIO ; lseek(fd: Pos: SEEK_SET) ; // modification du fichier WriteOK = write(fd:%addr(data): 15) ; Pos += 15 ; endif; endif; enddo;PCML issu de la compilation :
PCML après traitement par le PGM :
Avantages :
Inconvénients :
Extraction des informations du PCML d’un objet :
Prérequis : génération du PCML dans l’objet, les options de compilation peuvent être dans le source.
Cette méthode consiste à :
Programme d’extraction des informations PCML :
**free /if defined(*crtbndrpg) ctl-opt actgrp(*NEW) ; /endif ctl-opt option(*NODEBUGIO : *SRCSTMT); //-------------------------------------------------------------------------------------------------/ // Paramètre PGM Dcl-Pi *N; P_Objet Char(10) const; P_Lib Char(10) const; P_Type Char(10) const; P_Error Char(110); End-Pi; //-------------------------------------------------------------------------------------------------/ // DS objet et module pour appel APi dcl-ds qualname qualified based(TypeDef); Obj Char(10); Lib Char(10); end-ds; dcl-ds Qbn_Interface_Entry_t qualified based(TypeDef); // Offset from start of receiver Offset_Next_Entry int(10) ; Module_Name Char(10) ; Module_Library Char(10) ; Interface_Info_CCSID int(10) ; Interface_Info_Type int(10) ; Offset_Interface_Info int(10) ; Interface_Info_Length_Ret int(10) ; Interface_Info_Length_Avail int(10) ; end-ds; dcl-ds Qbn_PGII0100_t qualified based(TypeDef); Bytes_Returned int(10) ; Bytes_Available int(10) ; Obj_Name Char(10) ; Obj_Lib_Name Char(10) ; Obj_Type Char(10) ; Reserved3 Char(2) ; Offset_First_Entry int(10) ; Number_Entries int(10) ; end-ds; dcl-ds errcode qualified; bytesprov int(10) inz(0); bytesavail int(10) ; end-ds; dcl-ds psds psds ; codmsg char(7) pos(40); Libmsg char(100) pos(91); end-ds; // Define the initial storage for the first call to the API dcl-ds tempRcvr likeds(Qbn_PGII0100_t); dcl-ds rcvr likeds(Qbn_PGII0100_t) based(pRcvr); dcl-ds entry likeds(Qbn_Interface_Entry_t) based(pEntry); dcl-ds NomObj likeds(qualname); dcl-ds NomMod likeds(qualname); //-------------------------------------------------------------------------------------------------/ // Constantes dcl-c AllMod '*ALLBNDMOD' ; dcl-c LibModPGM 'QTEMP' ; dcl-c Format_retour 'RPII0100' ; // tailleXml doit avoir la même valeur que la variable XMLVALUE dcl-c tailleXml 8192 ; //-------------------------------------------------------------------------------------------------/ // Variables dcl-s pRcvr pointer inz(*null); dcl-s data Char(tailleXml) based(pData); dcl-s pcml Varchar(tailleXml); dcl-s len int(10); dcl-s i int(10); dcl-s entry_off int(10); //-------------------------------------------------------------------------------------------------/ // Prototype d'appel de l'API QBNRPII (Retrieve Program Interface Information) dcl-pr QBNRPII extpgm('QBNRPII') ; Receiver_variable likeds(Qbn_PGII0100_t); Length_of_receiver_variable int(10) const; Format_name Char(8) const; Qualified_object_name likeds(qualname) const; Object_Type Char(10) const ; Qualified_bound_module_name likeds(qualname) const; Error_code likeds(errcode); end-pr; // Prototype d'initialisation SQL dcl-pr initSQL end-pr; // Prototype déallocation mémoire dcl-pr cleanup end-pr; // Prototype extraction paramètre dcl-pr rtvparam ind end-pr; //-------------------------------------------------------------------------------------------------/ initSQL(); // Construction des DS objet et module pour l'appel de l'API NomObj.Obj = P_Objet ; NomObj.Lib = P_Lib ; if P_Type = '*PGM' ; // Dans le cas d'un programme, nom module = nom PGM et bib = QTEMP NomMod.Obj = P_Objet ; NomMod.Lib = LibModPGM ; else; // Dans le cas d'un programme de service, appel de l'API pour tous les modules NomMod.Obj = AllMod ; NomMod.Lib = *blanks ; endif; // Appel de l'API - détermination de la taille du retour contenant l'ensemble des PCML callp(e) QBNRPII (tempRcvr : %size(tempRcvr) : Format_retour : NomObj : P_Type : NomMod : errcode); // Non trouvé : objet ou programme ou bibliothèque if %error; P_Error = codmsg + ' - ' + libmsg ; cleanup() ; return; endif; // Pas de PCML if tempRcvr.Bytes_Available <= tempRcvr.Bytes_Returned; P_Error = 'Aucun PCML trouvé dans l''objet ' + P_Objet + ' de la bibliothèque ' + P_Lib ; cleanup() ; return; endif; pRcvr = %alloc(tempRcvr.Bytes_Available); callp(e) QBNRPII (rcvr : tempRcvr.Bytes_Available : Format_retour : NomObj : P_Type : NomMod : errcode); // Normalement, aucune erreur à ce niveau, mais par sécurité on refait les tests if %error or rcvr.Number_Entries = 0 ; if codmsg = *blanks ; P_Error = 'Erreur API - aucune donnée retournée'; else; P_Error = codmsg + ' - ' + libmsg ; endif; cleanup(); return; endif; // Lecture de la variable retour par PCML // --> Pour les *PGM, un seul PCML, pour les *SRVPGM, autant de PCML que de modules entry_off = rcvr.offset_First_Entry; for i = 1 to rcvr.Number_Entries; pEntry = pRcvr + entry_off; entry_off = entry.Offset_Next_Entry; pData = pRcvr + entry.Offset_Interface_Info; len = entry.Interface_Info_Length_Ret; // Si le PCML récupéré est plus grand que la taille de la variable prévue --> erreur if len > tailleXml ; P_Error = 'Taille PCML : ' + %char(len) + ' trop grande pour la variable retour : ' + %editc(tailleXml : 'X') ; cleanup() ; return; endif; pcml = %subst(data : 1: len); if not rtvparam() ; return; endif; endfor; cleanup(); P_Error = *blanks ; return; //----------------------------------------------------------------------------------------// // Procédure d'initialisation SQL // //----------------------------------------------------------------------------------------// dcl-Proc initSQL; Dcl-Pi *n end-Pi; // initialisation des options de compilation sql EXEC SQL Set Option Naming = *Sys, Commit = *None, UsrPrf = *User, DynUsrPrf = *User, Datfmt = *iso, CloSqlCsr = *EndMod; // création de la table de travail dans QTEMP, ou remise à blanc si elle existe déjà EXEC SQL create or replace table qtemp.wsparam (PROCNAME varchar(128), ENTRPT varchar(128), PARNAME varchar(128), USAGEIO varchar(11)) on replace delete rows; end-proc; //----------------------------------------------------------------------------------------// // Procédure de désallocation de la mémoire // //----------------------------------------------------------------------------------------// dcl-Proc Cleanup; Dcl-Pi *n end-Pi; if pRcvr <> *null and pRcvr <> %addr(tempRcvr); dealloc(n) pRcvr; endif; end-proc; //----------------------------------------------------------------------------------------// // Procédure d'extraction des paramètres // //----------------------------------------------------------------------------------------// dcl-Proc rtvparam; Dcl-Pi *n ind end-Pi; dcl-s XMLVALUE sqltype(XML_CLOB : 8192); // conversion du texte PCML en un champs XML EXEC SQL set :XMLVALUE = xmlparse(document :pcml) ; if sqlcode <> 0 ; P_Error = 'Erreur de conversion XML, SQLCODE = ' + %char(sqlcode); cleanup() ; return *off; endif; // Extraction du XML du nom du module, du nom de point d'entrée, du nom des paramètres et de leur usage, // dans une table temporaire de QTEMP EXEC SQL insert into qtemp.wsparam select x.* from xmltable('$d/pcml/program/data' passing :XMLVALUE as "d" columns PROCNAME varchar(128) path '../@name', ENTRPT varchar(128) path '../@entrypoint', PARNAME varchar(128) path '@name', USAGEIO varchar(11) path '@usage') as X ; if sqlcode <> 0 ; P_Error = 'Erreur insertion WSPARAM, SQLCODE = ' + %char(sqlcode); cleanup() ; return *off; endif; return *on ; END-PROC;A partir du fichier généré, vous pouvez gérer l’usage des paramètres :
Il ne reste plus qu’à créer le paramètre de la commande shell.
Extrait de code de la génération du paramètre -parameterUsage :
formalisme : -parameterUsage PROC1:i,o:PROC2:i,i,io
Attention à la casse des points d’entrée (PROC1 / PROC2…).
Dans le cas de web service de type REST, il faudra alimenter le fichier de propriété avec les bons usages des paramètres au lieu de construire le paramètre -parameterUsage.
Avantages :
Inconvénients :
Cette dernière méthode sera intégrée à la prochaine version de notre outils WEBCONSOLE.
Retrouvez-nous à l’université du i les 16 et 17 mai.
PCML: Publier un programme CLLE
Cette article est la suite de notre série sur le PCML
Nous avons vu que pour publier un programme en RPG ILE ou COBOL ILE . Le compilateur pouvait générer pour vous le PCML, mais si vous voulez publier un programme CLLE, vous devez faire vous même le PCML, ce n’est pas très compliqué à faire …
Pour vous faciliter la vie nous avons fait un outil qui permet de publier des programmes en CLLE, en générant pour vous le PCML .
La commande s’utilise comme ceci
Vous devrez lui indiquer
Le paramètre IFS peut être laissé à *DFT, dans ce cas le fichier s’appelle nomdupgm.PCML et il est placé dans le répertoire courant
Le paramètre version est facultatif, par défaut il indiquera 6.0.
Limites d’utilisation
Vos paramètres doivent être sur la même ligne
La syntaxe suivante n’est pas reconnue :
Les paramètres doivent avoir la même casse :
La syntaxe suivante n’est pas reconnue :
Le type des paramètres peut être uniquement *CHAR, *DEC, *INT
Exemple d’utilisation :
Le programme source suivant MONPGM
Donnera comme PCML
Complément :
Cette solution vous permet d’obtenir des paramètres en entrée et sortie, cas le plus usuel.
Nous avons ajouter un macro langage qui permet d’indiquer à GENCLPCML la nature de votre paramètre : vous pouvez indiquer sur la ligne de déclaration de votre variable les instructions suivantes
/*%%inp%%*/ pour un paramètre en input
/*%%out%%*/ pour un paramètre en output
Si vous n’indiquez rien votre paramètre sera en entrée/sortie
Soit le programme MONPGM
1 paramètre en entrée
1 en sortie
1 en entrée sortie
Produira le PCML suivant
Pour le récupérer l’outil
ci joint les sources : Télécharger le savf
Vous devez restaurer les sources et il suffit de les compiler en indiquant PGM(GENCLPCMLC) pour la génération de la commande et de lancer celle-ci pour tester.
PCML : mieux le comprendre pour en tirer partie
Le PCML (Program Call Markup Language), est un document généré par le compilateur pour décrire l’interface de vos programmes ou programmes de service. Il permet d’automatiser l’appel des programmes via Java ou d’autres langages.
En RPGLE, il existe 2 méthodes pour déclarer des paramètres.
Première solution
En carte C, méthode que l’on trouve encore sur des programmes existants : les paramètres sont considérés comme en entrée/sortie dans le PCML.
PCML généré :
Deuxième solution
En les prototypant soit en carte D soit en format full free.
On peut jouer en indiquant « const » sur les paramètres en entrée, ils seront bien uniquement en input dans le PCML.
Mais les autres paramètres resteront en entrée/sortie :
ou
PCML généré :
En CBLLE, il existe une seule solution pour déclarer les paramètres
Et les paramètres sont en entrée/sortie ….
Lors de la publication par l’interface web, on peut ajuster ces paramètres. Le plus souvent, en entrée ou en sortie, pour générer un WSDL efficace :
PCML obtenu après modification par l’outil de déploiement :
La complexité intervient, dans le cas où l’on veut bypasser l’interface web, pour automatiser des déploiements en utilisant les scripts SH.
Nos outils permettent la modification du PCML sans intervention manuelle. Pour cela, il vous faudra générer le fichier PCML dans un fichier IFS, celui généré dans le module n’étant pas modifiable :
CRTBNDRPG PGM(BERTHOIN/TESTPCML) SRCFILE(BERTHOIN/QRPGLESRC) PGMINFO(*PCML *STMF) INFOSTMF('/home/PLB/testpcml.pcml')Ces options ne peuvent pas être intégrés dans vos cartes H ou CTL-OPT
Vous devrez modifier le type de vos paramètres et indiquer votre fichier STMF dans la publication du webservice :
Versions
PCML a subi quelques évolutions il en est actuellement la version 7 depuis fin 2017. La version usuelle est toujours la 6 aujourd’hui. Cette dernière est indiquée dans le tag PCML :
Les principales évolutions
« entrypoint »
« passby »
« returnvalue »
« bidistringtype »
« threadsafe »
« chartype »
« epccsid »
« trim »
« dateformat »
« dateseparator »
« timeformat »
« timeseparator »
« varchar »
Remarque :
Vous n’obtenez pas la même syntaxe si vous générez directement le programme.
CRTBNDRPG ... <program name="TESTPCML" path="/QSYS.LIB/BERTHOIN.LIB/TESTPCML.PGM">ou si vous générez d’abord le module
CRTRPGMOD ... <program name="TESTPCML" entrypoint="TESTPCML">Soit pour un module
et pour un programme
La version par défaut est PCML 6, pour utiliser la version 7, vous devez le spécifier explicitement.
De plus, cela nécessite : PTF SI66150 (7.3) ou SI66149 (7.2) du 10/11/2017.
Pour l’utiliser
ctl-opt pgminfo(*pcml:*module:*dclcase:*v7) ;La différence V6/V7 porte sur la gestion des VARCHAR
V6 : VARCHAR considéré comme une DS
V7 : supporté nativement via le type « varchar »
<data name="STRIN" type="varchar" length="25" usage="input" />Cet article est le premier d’une série à suivre sur le PCML, rendez-vous très vite !
Access Solutions 1.1.7.3
La dernière version de ACS, 1.1.7.3 disponible depuis le 12 février 2018, apporte un certain nombre d’évolutions comme documenté ici par IBM :
En images, le résumé des nouveautés.
Base de données
Exécution de script SQL
Il est maintenant possible de personnaliser la bordure de la fenêtre. Très pratique quand vous ouvrez des sessions sur de multiples systèmes et/ou avec de multiples utilisateurs :
Gestion des journaux
Des options supplémentaires. A noter que la modification des droits est permise
Visual Explain
Le détail des option d’affichage est rappelé en dessous du graphique, avec reprise des codes couleurs.
Téléchargement des spoules
Choix de l’emplacement possible dans le fenêtre de téléchargement et plus uniquement dans les préférences globales.
IFS
Affichage du contenu avec gestion correcte des cssid
Affichage des droits
Non modifiable !
A très vite pour les prochaines évolutions.
Compiler les sources CL depuis l’IFS
La TR4 de la 7.3, ou la TR8 de le 7.2, apporte une petite modification aux commandes
Ces commandes supportent désormais le paramètre SRCSTMF : compilation d’un CL dont le source est dans l’IFS, comme le font les commandes CRTBNDRPG et CRTRPGMOD actuellement.
L’évolution peut paraître anecdotique, mais elle permet une meilleure intégration des développement Open Source, basés sur Git ou autres gestionnaires externes de sources.
Vous devez installer la PTF 5700SS1 SI66797 (7.3) afin de disposer de cette fonctionnalité.
Exemple :
Concrètement, le source est copié dans un fichier de QTEMP avant d’être compilé de façon classique :
Si vous utilisez des INCLUDE, cette commande est également modifiée, et vous avez la possibilité d’indiquer un répertoire contenant vos sources dans l’IFS.
Une remarque concernant l’intégration dans RDi :
Nul doute que cette fonctionnalité va permettre rapidement l’adoption de l’IFS. D’autres alternatives existent déjà, principalement dans le projet Open Source OSSILE https://github.com/OSSILE/OSSILE/tree/master/main/crtfrmstmf. Ce dernier garde tout son sens pour compiler depuis l’IFS n’importe quel source pour lequel le compilateur ne propose que les fichiers sources classiques (DSPF, …).
Webconsole version 1.0.2
Console pour serveurs de services web – 2
La console évolue, et passe désormais en version 1.0.1 : http://www.gaia.fr/download/utilitaires/webconsole.zip.
Pour prendre en compte vos retours et commentaires, cette version apporte principalement sur la capacité de gérer plusieurs partitions depuis un système. Vous retrouverez les informations de la version précédente (cf notre article de lancement http://www.gaia.fr/console-pour-serveurs-de-services-web/).
Nous continuons à faire évoluer cet outil, et à prendre en compte vos besoins. Une des prochaines phases sera le passage en Open Source !
Continuez à nous transmettre vos remarques et besoins.