Part 13 — Build Integration¶

plugins {
    id 'java'
    id 'war'  // For CICS web applications
}

group = 'com.yourcompany'
version = '1.0.0'

repositories {
    mavenCentral()
    maven {
        url 'https://your-artifact-repository/maven'
        credentials {
            username = project.findProperty('repoUser') ?: ''
            password = project.findProperty('repoPassword') ?: ''
        }
    }
}

// Dependencies
dependencies {
    // PLI Runtime (required)
    implementation 'com.heirloom:pli_runtime2:26.2.27.RC1'

    // Manifold (compile-time annotation processor)
    annotationProcessor 'com.heirloom:heirloom-manifold:2.0.0'
    implementation 'systems.manifold:manifold-props-rt:2024.1.42'

    // For CICS applications
    compileOnly 'jakarta.platform:jakarta.jakartaee-api:10.0.0'

    // For SQL/JDBC
    runtimeOnly 'com.ibm.db2:jcc:11.5.8.0'
    // Or PostgreSQL: runtimeOnly 'org.postgresql:postgresql:42.7.1'

    // For IBM MQ (if needed)
    implementation 'com.ibm.mq:com.ibm.mq.allclient:9.3.4.0'

    // Testing
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
    testImplementation 'org.mockito:mockito-core:5.8.0'
}

// Source directories
sourceSets {
    main {
        java {
            srcDirs = ['generated', 'src/main/java']
        }
        resources {
            srcDirs = ['src/main/resources']
        }
    }
}

// PLI Compiler configuration
ext {
    pliCompilerJar = file("${projectDir}/lib/pli_compiler2-26.2.27.RC1.jar")
    pliSourceDir = file('src/main/pli')
    javaTargetDir = file('generated')

    // Compilation strategy: 'static' for batch, 'instance' for CICS
    pliStrategy = project.findProperty('pliStrategy') ?: 'static'
}

// Task: Compile PL/I to Java
task compilePli(type: Exec) {
    description = 'Compile PL/I source files to Java'
    group = 'build'

    workingDir projectDir

    // Build command line
    def args = [
        'java', '-jar', pliCompilerJar,
        '--source', pliSourceDir,
        '--target', javaTargetDir,
        '--package', 'com.yourcompany.app',
        '--strategy', pliStrategy,
        '--cics',           // Enable CICS support
        '--sql',            // Enable SQL support
        '--loglevel', 'INFO'
    ]

    // Optional: Helper configuration
    def helperFile = file('src/main/resources/helper.json')
    if (helperFile.exists()) {
        args += ['--helper', helperFile.absolutePath]
    }

    commandLine args

    // Inputs/outputs for incremental build
    inputs.dir(pliSourceDir)
    outputs.dir(javaTargetDir)

    // Create output directory
    doFirst {
        javaTargetDir.mkdirs()
    }
}

// Run PLI compilation before Java compilation
compileJava.dependsOn compilePli

// Configure javac to use Manifold plugin
tasks.withType(JavaCompile) {
    options.compilerArgs += [
        '-Xplugin:Manifold',
        '--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED',
        '--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED',
        '--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED',
        '--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED',
        '--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
        '--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED'
    ]
    options.fork = true
    options.forkOptions.jvmArgs += [
        '--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED',
        '--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED',
        '--add-opens=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
        '--add-opens=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED'
    ]
}

// Task: Run a specific program (for batch testing)
task runProgram(type: JavaExec) {
    description = 'Run a specific PL/I program'
    group = 'application'

    classpath = sourceSets.main.runtimeClasspath
    mainClass = project.findProperty('mainClass') ?: 'com.yourcompany.app.MAIN'
    args = (project.findProperty('args') ?: '').split(',')

    // Set system properties for runtime
    systemProperty 'pli.config', 'config/pli.properties'
}

// Task: Create WAR for CICS deployment
war {
    archiveBaseName = 'myapp-cics'
    archiveVersion = version

    // Include generated classes
    from(sourceSets.main.output) {
        include '**/*.class'
    }
}

// Task: Create JAR for batch deployment
task batchJar(type: Jar) {
    description = 'Create JAR for batch execution'
    group = 'build'

    archiveBaseName = 'myapp-batch'
    archiveVersion = version

    from sourceSets.main.output

    manifest {
        attributes(
            'Main-Class': 'com.yourcompany.app.BatchMain',
            'Implementation-Version': version
        )
    }
}

// Clean task
clean {
    delete javaTargetDir
}

rootProject.name = 'enterprise-batch-system'

include 'common'
include 'wave1'
include 'wave2'
include 'wave3'
include 'wave4'
include 'wave5'

subprojects {
    apply plugin: 'java'

    repositories {
        mavenCentral()
    }

    dependencies {
        implementation 'com.heirloom:pli_runtime2:26.2.27.RC1'
        annotationProcessor 'com.heirloom:heirloom-manifold:2.0.0'
    }

    // Common PLI compilation configuration
    ext {
        pliCompilerJar = rootProject.file('lib/pli_compiler2-26.2.27.RC1.jar')
    }
}

// Wave-specific configuration
ext {
    pliSourceDir = file('src/main/pli')
    javaTargetDir = file('generated')
}

task compilePli(type: Exec) {
    // Same as before, but wave-specific
    commandLine 'java', '-jar', pliCompilerJar,
        '--source', pliSourceDir,
        '--target', javaTargetDir,
        '--package', 'com.yourcompany.wave1',
        '--strategy', 'static'
}

compileJava.dependsOn compilePli

pipeline {
    agent any

    tools {
        jdk 'JDK-11'
        gradle 'Gradle-8'
    }

    environment {
        PLI_COMPILER_JAR = "${WORKSPACE}/lib/pli_compiler2-26.2.27.RC1.jar"
    }

    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', url: 'https://git.yourcompany.com/pli-app.git'
            }
        }

        stage('Compile PL/I') {
            steps {
                sh './gradlew compilePli'
            }
        }

        stage('Build Java') {
            steps {
                sh './gradlew build'
            }
        }

        stage('Test') {
            steps {
                sh './gradlew test'
            }
            post {
                always {
                    junit '**/build/test-results/test/*.xml'
                }
            }
        }

        stage('Package') {
            steps {
                sh './gradlew war'
            }
        }

        stage('Deploy to Dev') {
            when {
                branch 'develop'
            }
            steps {
                sh './deploy-to-dev.sh build/libs/myapp-cics.war'
            }
        }

        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                input message: 'Deploy to production?', ok: 'Deploy'
                sh './deploy-to-prod.sh build/libs/myapp-cics.war'
            }
        }
    }

    post {
        success {
            emailext subject: "Build SUCCESS: ${env.JOB_NAME}",
                     body: "Build ${env.BUILD_NUMBER} succeeded",
                     to: 'team@yourcompany.com'
        }
        failure {
            emailext subject: "Build FAILED: ${env.JOB_NAME}",
                     body: "Build ${env.BUILD_NUMBER} failed",
                     to: 'team@yourcompany.com'
        }
    }
}

task compilePli(type: Exec) {
    // Enable incremental build
    inputs.dir(pliSourceDir)
    outputs.dir(javaTargetDir)

    // Only recompile if PL/I sources changed
    onlyIf {
        !javaTargetDir.exists() ||
        pliSourceDir.listFiles().any {
            it.lastModified() > javaTargetDir.lastModified()
        }
    }
}

// Enable build cache in gradle.properties
org.gradle.caching=true

// Configure remote cache
buildCache {
    remote(HttpBuildCache) {
        url = 'https://cache.yourcompany.com/'
        push = true
        credentials {
            username = System.getenv('CACHE_USER')
            password = System.getenv('CACHE_PASSWORD')
        }
    }
}

ext {
    pliCompilerJar = file("${System.getenv('PLI_COMPILER_HOME')}/pli_compiler2.jar")
}

task compilePli(type: Exec) {
    // Fail build if PLI compilation fails
    ignoreExitValue = false

    // Log output
    standardOutput = System.out
    errorOutput = System.err
}