apply plugin: DockerRemoteApiPlugin


/*
 * Copyright OpenSearch Contributors
 * SPDX-License-Identifier: Apache-2.0
 */


import com.bmuschko.gradle.docker.DockerRemoteApiPlugin
import com.bmuschko.gradle.docker.tasks.container.DockerCreateContainer
import com.bmuschko.gradle.docker.tasks.container.DockerRemoveContainer
import com.bmuschko.gradle.docker.tasks.container.DockerStartContainer
import com.bmuschko.gradle.docker.tasks.container.DockerStopContainer
import com.bmuschko.gradle.docker.tasks.image.DockerBuildImage
import com.bmuschko.gradle.docker.tasks.image.DockerPullImage
import com.bmuschko.gradle.docker.tasks.image.Dockerfile
import com.bmuschko.gradle.docker.tasks.network.DockerCreateNetwork
import com.bmuschko.gradle.docker.tasks.network.DockerRemoveNetwork

/**
 * End-to-end test docker network
 */
task createDataPrepperNetwork(type: DockerCreateNetwork) {
    networkName = "data_prepper_network"
}

task removeDataPrepperNetwork(type: DockerRemoveNetwork) {
    dependsOn createDataPrepperNetwork
    networkId = createDataPrepperNetwork.getNetworkId()
}

def BASIC_GROK_PIPELINE_YAML = "basic-grok-e2e-pipeline.yml"
def PARALLEL_GROK_SUBSTITUTE_PIPELINE_YAML = "parallel-grok-substitute-e2e-pipeline.yml"
def DATA_PREPPER_CONFIG_YAML = "data_prepper.yml"

/**
 * DataPrepper Docker tasks
 */
task createDataPrepperDockerFile(type: Dockerfile) {
    dependsOn copyDataPrepperJar
    destFile = project.file('build/docker/Dockerfile')
    from(dataPrepperBaseImage)
    workingDir("/app/data-prepper")
    copyFile("${dataPrepperJarFilepath}", "/app/data-prepper/lib")
    defaultCommand('java', '-Ddata-prepper.dir=/app/data-prepper', '-cp', '/app/data-prepper/lib/*', 'org.opensearch.dataprepper.DataPrepperExecute')
}

task buildDataPrepperDockerImage(type: DockerBuildImage) {
    dependsOn createDataPrepperDockerFile
    inputDir  = file(".")
    dockerFile  = file("build/docker/Dockerfile")
    images.add("e2e-test-log-pipeline-image")
}

def createDataPrepperDockerContainer(final String taskBaseName, final String dataPrepperName, final int sourcePort,
                                     final int serverPort, final String pipelineConfigYAML, final String dataPrepperConfigYAML) {
    return tasks.create("create${taskBaseName}", DockerCreateContainer) {
        dependsOn buildDataPrepperDockerImage
        dependsOn createDataPrepperNetwork
        containerName = dataPrepperName
        exposePorts("tcp", [2021, 4900])
        hostConfig.portBindings = [String.format('%d:2021', sourcePort), String.format('%d:4900', serverPort)]
        hostConfig.binds = [(project.file("src/integrationTest/resources/${pipelineConfigYAML}").toString()):"/app/data-prepper/pipelines/pipelines.yaml",
                            (project.file("src/integrationTest/resources/${dataPrepperConfigYAML}").toString()):"/app/data-prepper/config/data-prepper-config.yaml"]
        hostConfig.network = createDataPrepperNetwork.getNetworkName()
        cmd = ['java', '-Ddata-prepper.dir=/app/data-prepper', '-cp', '/app/data-prepper/lib/*', 'org.opensearch.dataprepper.DataPrepperExecute']
        targetImageId buildDataPrepperDockerImage.getImageId()
    }
}

def startDataPrepperDockerContainer(final DockerCreateContainer createDataPrepperDockerContainerTask) {
    return tasks.create("start${createDataPrepperDockerContainerTask.getName()}", DockerStartContainer) {
        dependsOn createDataPrepperDockerContainerTask
        targetContainerId createDataPrepperDockerContainerTask.getContainerId()
    }
}

def stopDataPrepperDockerContainer(final DockerStartContainer startDataPrepperDockerContainerTask) {
    return tasks.create("stop${startDataPrepperDockerContainerTask.getName()}", DockerStopContainer) {
        targetContainerId startDataPrepperDockerContainerTask.getContainerId()
    }
}

def removeDataPrepperDockerContainer(final DockerStopContainer stopDataPrepperDockerContainerTask) {
    return tasks.create("remove${stopDataPrepperDockerContainerTask.getName()}", DockerRemoveContainer) {
        targetContainerId stopDataPrepperDockerContainerTask.getContainerId()
    }
}

/**
 * OpenSearch Docker tasks
 */
task pullOpenSearchDockerImage(type: DockerPullImage) {
    image = "opensearchproject/opensearch:${libs.versions.opensearch.get()}"
}

task createOpenSearchDockerContainer(type: DockerCreateContainer) {
    dependsOn createDataPrepperNetwork
    dependsOn pullOpenSearchDockerImage
    targetImageId pullOpenSearchDockerImage.image
    containerName = "node-0.example.com"
    hostConfig.portBindings = ['9200:9200', '9600:9600']
    hostConfig.autoRemove = true
    hostConfig.network = createDataPrepperNetwork.getNetworkName()
    envVars = ['discovery.type':'single-node']
}

task startOpenSearchDockerContainer(type: DockerStartContainer) {
    dependsOn createOpenSearchDockerContainer
    targetContainerId createOpenSearchDockerContainer.getContainerId()

    doLast {
        sleep(90*1000)
    }
}

task stopOpenSearchDockerContainer(type: DockerStopContainer) {
    targetContainerId createOpenSearchDockerContainer.getContainerId()

    doLast {
        sleep(5*1000)
    }
}

/**
 * End to end test. Spins up OpenSearch and DataPrepper docker containers, then runs the integ test
 * Stops the docker containers when finished
 */
task basicLogEndToEndTest(type: Test) {
    dependsOn build
    dependsOn startOpenSearchDockerContainer
    def createDataPrepperTask = createDataPrepperDockerContainer(
            "basicLogDataPrepper", "dataprepper", 2021, 4900, "${BASIC_GROK_PIPELINE_YAML}", "${DATA_PREPPER_CONFIG_YAML}")
    def startDataPrepperTask = startDataPrepperDockerContainer(createDataPrepperTask as DockerCreateContainer)
    dependsOn startDataPrepperTask
    startDataPrepperTask.mustRunAfter 'startOpenSearchDockerContainer'
    // wait for data-preppers to be ready
    doFirst {
        sleep(15*1000)
    }

    description = 'Runs the basic grok end-to-end test.'
    group = 'verification'
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath

    filter {
        includeTestsMatching "org.opensearch.dataprepper.integration.log.EndToEndBasicLogTest.testPipelineEndToEnd*"
    }

    finalizedBy stopOpenSearchDockerContainer
    def stopDataPrepperTask = stopDataPrepperDockerContainer(startDataPrepperTask as DockerStartContainer)
    finalizedBy stopDataPrepperTask
    finalizedBy removeDataPrepperDockerContainer(stopDataPrepperTask as DockerStopContainer)
    finalizedBy removeDataPrepperNetwork
}

task parallelGrokStringSubstituteTest(type: Test) {
    dependsOn build
    dependsOn startOpenSearchDockerContainer
    def createDataPrepperTask = createDataPrepperDockerContainer(
            "ParallelGrokSubstLogDataPrepper", "dataprepper-pgsts-test", 2021, 4900, "${PARALLEL_GROK_SUBSTITUTE_PIPELINE_YAML}", "${DATA_PREPPER_CONFIG_YAML}")
    def startDataPrepperTask = startDataPrepperDockerContainer(createDataPrepperTask as DockerCreateContainer)
    dependsOn startDataPrepperTask
    startDataPrepperTask.mustRunAfter 'startOpenSearchDockerContainer'
    // wait for data-preppers to be ready
    doFirst {
        sleep(15*1000)
    }

    description = 'Runs the parallel grok and string substitute end-to-end test.'
    group = 'verification'
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath

    filter {
        includeTestsMatching "org.opensearch.dataprepper.integration.log.ParallelGrokStringSubstituteLogTest.testPipelineEndToEnd*"
    }

    finalizedBy stopOpenSearchDockerContainer
    def stopDataPrepperTask = stopDataPrepperDockerContainer(startDataPrepperTask as DockerStartContainer)
    finalizedBy stopDataPrepperTask
    finalizedBy removeDataPrepperDockerContainer(stopDataPrepperTask as DockerStopContainer)
    finalizedBy removeDataPrepperNetwork
}

dependencies {
    integrationTestImplementation project(':data-prepper-api')
    integrationTestImplementation project(':data-prepper-plugins:common')
    integrationTestImplementation project(':data-prepper-plugins:log-generator-source')
    integrationTestImplementation project(':data-prepper-plugins:opensearch')
    integrationTestImplementation project(':data-prepper-plugins:aws-plugin-api')
    integrationTestImplementation libs.armeria.core
    integrationTestImplementation testLibs.awaitility
    integrationTestImplementation libs.opensearch.rhlc
}