Application Java CICS-Run - (3) Gestion de build avec Gradle
introduction
CICS TS V5.6 prend également en charge Gradle en tant qu'outil de gestion de build pour les applications CICS-Java, avec Maven. Ici, nous allons essayer de gérer la construction de l'application CICS-Java à l'aide de Gradle.
Article associé
Application Java CICS-Exécuter - (1) Exécuter un exemple d'application simple Application Java CICS-Run - (2) Build management by Maven Application Java CICS-Run - (3) Build management by Gradle Application Java CICS-Run - (4) Application Spring Boot
Préparation préalable
Ceci est similaire au cas de Maven. (Utilisez Gradle au lieu de Maven)
Environnement de développement Java EE approprié
Veuillez utiliser Eclipse, VS Code, etc. qui peuvent développer des applications Java EE selon le cas. Puisque nous utiliserons l'exemple tel qu'il est cette fois, nous n'éditerons pas la source en particulier, nous n'avons donc pas à l'utiliser, mais nous utiliserons généralement une sorte d'environnement de développement. Ce serait bien de pouvoir travailler avec Gradle, git, etc. Si vous souhaitez utiliser CICS Explorer ensemble, vous pouvez utiliser Eclipse.
CICS Explorer
Cela n'est pas non plus obligatoire, mais il peut être utilisé pour vérifier la définition de ressource de CICS. Téléchargez et configurez un outil basé sur Eclipse appelé CICS Explorer en vous référant aux zones suivantes. Référence: Téléchargement et démarrage de CICS Explorer
- Cet outil est un outil gratuit pour les utilisateurs de CICS.
Gradle Suivez les étapes ci-dessous pour installer. Installing Gradle Fondamentalement, décompressez simplement celui téléchargé et passez-le par le chemin.
Comme prérequis, Java 8 ou version ultérieure est requis.
c:\>java -version
java version "1.8.0_144"
Java(TM) SE Runtime Environment (build 1.8.0_144-b01)
Java HotSpot(TM) 64-Bit Server VM (build 25.144-b01, mixed mode)
Téléchargez la dernière version de Gradle V6.5 pour le moment à partir de ce qui suit (gradle-6.5.zip). Releases
Extrayez-le dans un répertoire approprié. (Ici (c: \ x \ Gradle \ gradle-6.5 ) Ajoutez le bac de destination (C: \ x \ Gradle \ gradle-6.5 \ bin) à votre PATH.
Vérification
c:\>gradle -v
------------------------------------------------------------
Gradle 6.5
------------------------------------------------------------
Build time: 2020-06-02 20:46:21 UTC
Revision: a27f41e4ae5e8a41ab9b19f8dd6d86d7b384dad4
Kotlin: 1.3.72
Groovy: 2.5.11
Ant: Apache Ant(TM) version 1.10.7 compiled on September 1 2019
JVM: 1.8.0_144 (Oracle Corporation 25.144-b01)
OS: Windows 10 10.0 amd64
C'est acceptable.
git
Nous allons obtenir et utiliser l'exemple fourni sur gitHub, donc installez également git. La méthode de configuration est omise car elle traîne.
c:\>git --version
git version 2.21.0.windows.1
Environnement d'exécution (z / OS, CICS)
- Le côté hôte est exactement le même que celui de l'affaire Maven. Si vous avez déjà implémenté le scénario Maven, vous pouvez utiliser le même que celui-ci.
Préparez une région CICS pour exécuter l'exemple. Pour l'instant, nous allons utiliser une région nommée ** CT56B4A1 ** sous contrôle CICSplex. Ajoutez une ressource appelée JVMServer pour exécuter des applications Java. Cette fois, nous allons utiliser l'exemple pour CICS-Liberty (application JavaEE), donc créez un serveur JVM pour Liberty.
Profil JVM
Préparez le profil JVM sur USS. (Les propriétés liées à JVMServer sont effectivement spécifiées dans le fichier de cet USS. La définition de ressource JVMSERVER pointe vers le nom de fichier de ce profil JVM.) Un échantillon est fourni, alors copiez-le et utilisez-le.
Créez un répertoire appelé / var / cicsts / cicsts56 / CT56B4A1 / JVMProfiles et copiez-y /usr/lpp/cicsts/cicsts56/JVMProfiles/DFHOSGI.jvmprofile (exemple de définition pour OSGi situé sous le répertoire d'installation du CCD). Faire. Personnalisez en fonction de votre environnement.
DFHWLP.extrait jvmprofile
JAVA_HOME=/usr/lpp/java/J8.0_64/
WORK_DIR=/var/cicsts/cicsts56/CT56B4A1/work
WLP_INSTALL_DIR=/usr/lpp/cicsts/cicsts56/wlp
-Dcom.ibm.cics.jvmserver.wlp.autoconfigure=true
-Dcom.ibm.cics.jvmserver.wlp.server.host=*
-Dcom.ibm.cics.jvmserver.wlp.server.http.port=56441
-Dcom.ibm.cics.jvmserver.wlp.server.https.port=56451
-Xms128M
-Xmx256M
-Xmso1M
-Xgcpolicy:gencon
-Xscmx256M
-Xshareclasses:name=cicsts%g,groupAccess,nonfatal
-Xtune:virtualized
-Dcom.ibm.tools.attach.enable=no
-Dfile.encoding=ISO-8859-1
_BPXK_DISABLE_SHLIB=YES
SIT
Spécifiez le répertoire où se trouve le fichier de propriétés ci-dessus dans le paramètre SIT "JVMPROFILEDIR".
JVMPROFILEDIR=/var/cicsts/cicsts56/CT56B4A1/JVMProfiles
Redémarrez la région pour que les modifications prennent effet.
Définition du serveur JVM
Préparez la définition de ressource JVMSERVER. Copiez la définition JVMSERVER "DFHWLP" dans le groupe DFH $ WLP fourni par le produit dans un groupe approprié et installez-le.
OBJECT CHARACTERISTICS CICS RELEASE = 0730
CEDA View JVmserver( DFHWLP )
JVmserver : DFHWLP
Group : TAGGRP
DEScription : CICS JVM server to run WLP samples
Status : Enabled Enabled | Disabled
Jvmprofile : DFHWLP (Mixed Case
Lerunopts : DFHAXRO
Threadlimit : 015 1-256
DEFINITION SIGNATURE
DEFinetime : 06/04/20 16:20:21
CHANGETime : 06/04/20 16:20:21
CHANGEUsrid : CICSUSER
CHANGEAGEnt : CSDApi CSDApi | CSDBatch
CHANGEAGRel : 0730
- Jvmprofile: DFHWLP, ce qui signifie que le fichier DFHWLP.jvmprofile sous le répertoire spécifié dans JVMPROFILEDIR de SIT est utilisé comme fichier de propriétés JVM.
Il est OK s'il est activé en regardant CEMT I JVMSERVER.
I JVMS
STATUS: RESULTS - OVERTYPE TO MODIFY
Jvm(DFHWLP ) Ena Prf(DFHWLP ) Ler(DFHAXRO )
Threadc(005) Threadl( 015 ) Cur(48314096)
CICS Bundle Deployment API Vous devez avoir configuré l'API de déploiement de bundle CICS, disponible à partir de CICS TS V5.6. Cette fonctionnalité a été ajoutée pour le déploiement d'applications en tant que l'une des API de gestion REST appelées CMCI. Configurez CMCI sur le serveur WUI qui gère la région CICS cible et spécifiez les paramètres de l'API de déploiement de bundle CICS dans les propriétés du serveur JVM CMCI. Référence: Fonctionnement: API de déploiement du bundle CICS
Les paramètres minimum requis sont les suivants.
Créez un répertoire sur USS pour le placement de fichiers Bundle. Ici, il s'agit de / var / cicsts / cicsts56 / bundles.
Définissez les paramètres suivants dans le profil JVM (EYUCMCIJ.jvmprofile) pour le serveur JVM CMCI de WUI.
-Dcom.ibm.cics.jvmserver.cmci.bundles.dir=/var/cicsts/cicsts56/bundles
Exemple de contrôle de fonctionnement
Clonage local
Clonez https: // github.com / IBM / cics-bundle-gradle.git dans un répertoire approprié sur votre PC local.
C:\y\workspace\cicsts56>git clone https://github.com/IBM/cics-bundle-gradle.git
Cloning into 'cics-bundle-gradle'...
remote: Enumerating objects: 125, done.
remote: Counting objects: 100% (125/125), done.
remote: Compressing objects: 100% (87/87), done.
remote: Total 1855 (delta 43), reused 86 (delta 13), pack-reused 1730Receiving objects: 99% (1837/1855), 2.08 MiB | 2.01 MiB/s
Receiving objects: 100% (1855/1855), 4.19 MiB | 2.83 MiB/s, done.
Resolving deltas: 100% (610/610), done.
Comprendre la structure des fichiers
Nous utiliserons un exemple appelé gradle-multipart-sample sous samples, alors déplacez le répertoire et voyez la structure du fichier.
C:\y\workspace\cicsts56\cics-bundle-gradle\samples\gradle-multipart-sample>tree /f /a
Liste des chemins de dossier:Volume Windows
Le numéro de série du volume est 1866-E2FC
C:.
| build.gradle
| gradlew
| gradlew.bat
| README.md
| settings.gradle
|
+---gradle
| \---wrapper
| gradle-wrapper.jar
| gradle-wrapper.properties
|
+---gradle-bundle-demo
| build.gradle
|
\---gradle-war-demo
| build.gradle
|
\---src
\---main
+---java
| \---demo
| SimpleServlet.java
|
\---web-app
| index.html
| index.js
| style.css
|
+---images
| cics.png
|
\---WEB-INF
web.xml
Il existe plusieurs build.gradle et il a une structure hiérarchique, qui est une structure appelée "multi-projet" de Gradle. Référence: Bases du multi-projet avec Gradle
Normalement, lors de la création d'une application CICS-Java, créez un projet OSGi (jar) ou un projet Web (WAR) qui est le corps principal de l'application, créez un projet de bundle CICS pour organiser l'application et déployez-les en tant que package unique. Faites ça.
Dans cet exemple, la partie gradle-war-demo correspond au projet du corps de l'application (WAR), et la partie gradle-bundle-demo correspond au projet de bundle CICS, et afin de les regrouper, le parent Il est résumé dans le projet gradle-multipart-sample. La relation entre build.gradle est la suivante.
Il semble que vous puissiez également afficher la relation du projet avec la commande suivante.
c:\y\workspace\cicsts56\cics-bundle-gradle\samples\gradle-multipart-sample>gradle -q projects
------------------------------------------------------------
Root project
------------------------------------------------------------
Root project 'gradle-multipart-sample'
+--- Project ':gradle-bundle-demo'
\--- Project ':gradle-war-demo'
To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :gradle-bundle-demo-test04:tasks
Vérifier / modifier le contenu
gradle-war-demo (application javaEE)
Il s'agit d'une application Web censée s'exécuter sur CICS-Liberty. Il est implémenté par simple html et servlet. (Il ressemble à l'exemple Maven)
SimpleServlet.java
package demo;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.ibm.cics.server.InvalidRequestException;
import com.ibm.cics.server.Task;
/**
* Servlet implementation class SimpleServlet
*/
@WebServlet("/SimpleServlet")
public class SimpleServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html");
response.getWriter().print("Hello world!");
Task task = Task.getTask();
try {
String userid = task.getUSERID();
response.setContentType("text/html");
response.getWriter().print("\nI am " + userid);
} catch (InvalidRequestException e) {
throw new RuntimeException(e);
}
}
}
Le processus consiste à acquérir l'objet de la propre tâche exécutée dans la classe de tâches de JCICS, à acquérir les informations utilisateur qui s'exécutent à partir de celle-ci et à les afficher.
Il n'est pas nécessaire de changer l'application elle-même, alors vérifiez simplement le contenu.
gradle-bundle-demo (ensemble CICS)
Normalement, lors de la création d'une application CICS-Java avec CICS Explorer (si vous n'utilisez pas Gradle), vous créez un projet de bundle CICS et définissez les applications (WAR, OSGi, etc.) à y inclure. En conséquence, des fichiers tels que cics.xml et xxx.warbundle seront créés.
C'est l'équivalent du projet de bundle CICS, mais seul build.gradle existe. En spécifiant la dépendance à l'aide du mécanisme Gradle, il semble que le plug-in Gradle (cics-bundle-gradle) fourni par CICS crée automatiquement les fichiers requis pour le projet de bundle CICS. Par conséquent, en tant qu'utilisateur, vous devez uniquement définir les paramètres nécessaires dans build.gradle et vous n'avez pas à connaître directement le projet de bundle CICS.
Modifiez build.gradle en fonction de votre environnement. Les changements sont décrits dans les commentaires (1) - (7)
gradle-bundle-demo-test04\build.gradle
plugins {
id 'com.ibm.cics.bundle' version '1.0.0'
}
group 'com.ibm.cics'
version '1.0.0'
repositories {
mavenCentral()
}
cicsBundle {
build {
defaultJVMServer = 'DFHWLP' // (1)Nom JVMSERVER
}
deploy {
cicsplex = 'C73PLX' // (2)Le nom CICSplex auquel appartient la région CICS cible
region = 'CT56B4A1' // (3)Nom de la région CICS cible
bunddef = 'GRDBUNDL' // (4)Nom de ressource de définition de bundle défini sur la région CICS cible
csdgroup = 'TAGGRP' // (5) (4)Nom du groupe CSD auquel la définition de bundle de
url = 'http://etp1:56002' // (6)URL CMCI WUI
username = 'TAG' // (7)Avec l'utilisateur utilisé lors de l'émission de l'API de déploiement par CMCI
password = '********' //mot de passe
//caution: uncomment the line below to disable TLS/SSL checking for certificates
//insecure = true
}
}
dependencies {
cicsBundlePart group: 'org.codehaus.cargo', name: 'simple-war', version: '1.7.7', ext: 'war'
cicsBundlePart project(path:':gradle-war-demo', configuration: 'archives')
}
Maintenant, j'ai changé le nom du répertoire du projet pour le bundle CICS de gradle-bundle-demo en gradle-bundle-demo-test04. Ce nom de répertoire sera utilisé comme nom de répertoire lors du transfert de produits sur USS. Un répertoire appelé <nom du projet de bundle CICS> _ <version> est créé dans le répertoire pour organiser le répertoire de bundle spécifié par le serveur JVM de WUI (ici / var / cicsts / cicsts56 / bundles), et divers fichiers sont créés. Est élargi.
Exemple: / var / cicsts / cicsts56 / gradle-bundle-demo-test04_1.0.0 /
Les autres paramètres de modification sont les suivants.
** (1) defaultjvmserver **: spécifiez le nom du JVMSERVER pour exécuter l'application. Il doit être installé au préalable dans la région CICS cible.
** (2) cicsplex **: Le nom du CICSplex auquel appartient la région CICS cible
** (3) region **: nom de la région CICS cible
** (4) bundledef **: nom de ressource de définition de bundle défini sur la région CICS cible
** (5) csdgroup **: nom du groupe CSD auquel appartient la définition de bundle de (5)
** (6) url **: spécifiez l'URL CMCI de WUI. L'API de déploiement de bundle CICS doit être activée pour cette WUI. (S'il s'agit d'un modèle, il n'y a pas de description de http: //, mais si vous ne le spécifiez pas, une erreur se produira, alors soyez prudent!)
** (7) nom d'utilisateur / mot de passe **: utilisateur et mot de passe utilisés lors de l'émission de l'API de déploiement par CMCI
- Ici, l'opération de construction / déploiement n'est pas encore effectuée.
Puisque nous avons renommé le répertoire du projet, nous modifierons le paramètre parent setting.gradle en conséquence.
setting.gradle
rootProject.name = 'gradle-multipart-sample'
include 'gradle-war-demo'
include 'gradle-bundle-demo-test04'
Création de définition de BUNDLE
Créez une définition de bundle en fonction du contenu spécifié dans build.gradle ci-dessus.
OBJECT CHARACTERISTICS CICS RELEASE = 0730
CEDA View Bundle( GRDBUNDL )
Bundle : GRDBUNDL
Group : TAGGRP
DEScription : CICS-BUNDLE-DEMO
Status : Enabled Enabled | Disabled
BUndledir : /var/cicsts/cicsts56/bundles/gradle-bundle-demo-test04_1.0
(Mixed Case) : .0
:
:
:
BAsescope :
(Mixed Case) :
:
:
:
DEFINITION SIGNATURE
DEFinetime : 06/17/20 14:19:33
Le groupe CSD est spécifié (5), le nom de la définition BUNDLE est (4) et BUNDLEDIR est spécifié en fonction du nom du répertoire du projet et de la valeur des informations de version.
- Ici, l'opération d'installation n'est pas encore effectuée.
Modification de l'échantillon
- Ajout: Depuis que l'échantillon sur github a été modifié, la correspondance décrite ici n'est plus nécessaire. Référence: "web-app" doit être "webapp" dans l'exemple gradle-war-demo n ° 74
Je pense que cela sera corrigé bientôt, mais il y a un défaut dans la structure de répertoire de l'échantillon fourni, et si le traitement ultérieur est effectué tel quel, l'échantillon ne fonctionnera pas correctement.
Il existe un répertoire appelé ... \ gradle-multipart-sample \ gradle-war-demo \ src \ main \ web-app \, mais changez cette web-app en webapp. Supprimons les traits d'union.
En ce qui concerne le fonctionnement du plug-in Gradle's War, par défaut les fichiers sous webapp sont copiés lors de la création d'un WAR, mais dans l'exemple, il s'agit de web-app, donc web.xml et index.html sous ce répertoire Etc. ne sera pas copié et l'exemple d'application ne pourra pas être appelé.
Référence: Gradle --The War Plugin
The default behavior of the War task is to copy the content of src/main/webapp to the root of the archive. Your webapp directory may of course contain a WEB-INF sub-directory, which may contain a web.xml file. Your compiled classes are compiled to WEB-INF/classes. All the dependencies of the runtime [1] configuration are copied to WEB-INF/lib.
Exécution de construction / déploiement
- Dans la procédure suivante, build "gradelw build" et deploy "gradlew deployCICSBundle" sont exécutés en deux étapes, mais l'exécution build-deploy est effectuée uniquement avec la dernière commande.
Pour créer, exécutez la commande suivante dans le répertoire gradle-multipart-sample. Au début, cela prend du temps car les packages nécessaires sont téléchargés.
c:\y\workspace\cicsts56\cics-bundle-gradle\samples\gradle-multipart-sample>gradlew build
Downloading https://services.gradle.org/distributions/gradle-5.0-all.zip
...........................................................................................................................
Welcome to Gradle 5.0!
Here are the highlights of this release:
- Kotlin DSL 1.0
- Task timeouts
- Dependency alignment aka BOM support
- Interactive `gradle init`
For more details see https://docs.gradle.org/5.0/release-notes.html
Starting a Gradle Daemon (subsequent builds will be faster)
> Task :gradle-bundle-demo-test04:buildCICSBundle
Adding Java-based bundle parts from 'cicsBundlePart' dependency configuration
Adding Java-based bundle part: 'C:\Users\TomohiroTaguchi\.gradle\caches\modules-2\files-2.1\org.codehaus.cargo\simple-war\1.7.7\5f462015066db63c2e240b4fc3674c6f4910bb73\simple-war-1.7.7.war'
Adding Java-based bundle part: 'C:\y\workspace\cicsts56\cics-bundle-gradle\samples\gradle-multipart-sample\gradle-war-demo\build\libs\gradle-war-demo-1.0.0.war'
Adding non-Java-based bundle parts from 'src/main/resources'
BUILD SUCCESSFUL in 1m 12s
4 actionable tasks: 4 executed
Le projet est maintenant construit. Sous le répertoire gradle-bundle-demo, chaque fichier du projet de bundle CICS et un fichier zip (utilisé au moment du déploiement) qui les récapitule sont générés.
c:\y\workspace\cicsts56\cics-bundle-gradle\samples\gradle-multipart-sample>tree gradle-bundle-demo-test04 /f /a
Liste des chemins de dossier:Volume Windows
Le numéro de série du volume est 1866-E2FC
C:\Y\WORKSPACE\CICSTS56\CICS-BUNDLE-GRADLE\SAMPLES\GRADLE-MULTIPART-SAMPLE\GRADLE-BUNDLE-DEMO-TEST04
| build.gradle
|
\---build
+---distributions
| gradle-bundle-demo-test04-1.0.0.zip
|
\---gradle-bundle-demo-test04-1.0.0
| gradle-war-demo-1.0.0.war
| gradle-war-demo-1.0.0.warbundle
| simple-war-1.7.7.war
| simple-war-1.7.7.warbundle
|
\---META-INF
cics.xml
Ensuite, effectuez le travail de déploiement. Exécutez la commande suivante dans le répertoire gradle-multipart-sample.
c:\y\workspace\cicsts56\cics-bundle-gradle\samples\gradle-multipart-sample>gradlew deployCICSBundle
> Task :gradle-bundle-demo-test04:deployCICSBundle
Task deployCICSBundle
BUILD SUCCESSFUL in 12s
5 actionable tasks: 1 executed, 4 up-to-date
Si vous examinez l'état des ensembles et des composants groupés dans CICS Explorer, vous pouvez voir qu'ils ont été correctement installés et activés.
En d'autres termes, la commande Gradle ci-dessus a effectué le traitement suivant.
Build: Compilez l'application JavaEE (gradle-war-demo) / Create WAR, Generate CICS bundle (gradle-bundle-demo) Package: Emballage des modules associés Déployer: transférer / déployer le fichier de bundle CICS vers USS, installer la définition BUNDLE
Vérification du fonctionnement de l'application
Essayez d'accéder à l'application déployée sur Liberty en cours d'exécution sur le CICS cible à partir de votre navigateur.
Puisqu'il s'exécute en tant qu'utilisateur par défaut "CICSUSER", ce nom d'utilisateur s'affiche.
Avec cela, j'ai pu confirmer que l'application fonctionne correctement!
Recommended Posts