CODEWITHSUNDEEP
gradlebuild.gradle
Dominik
Dominik

Reputation: 141

Gradle: remove some files from an existing war | for each war-file do: unpack, remove/filter, assemble war

I'm relatively new to gradle, so this might be a typical newbee-question.

In our gradle build, we have a set of war files (dependencies) that all include a file that we need to remove from those war files, before building our ear file.

How can I achieve the following:

- for all war files in a folder,
  - extract war content to a location (using a Copy task & zipTree)
  - re-pack to a new war applying a filter (using War & excludes)

I assume I'll create a new task and add some 'dependsOn' declarations.

task excludeUnwantedFiles(){

    file(directoryWithOriginalWars).eachFile  { file ->
        ???? unpack war, filter, assemble new war file ????
    }
}

ear.dependsOn(excludeUnwantedFiles)
excludeUnwantedFiles.dependsOn(downloadAllOriginalWarsIntoDirectory)

How do I create that task, that executes for each war-file? What is the best way to do this?

Is there a way I can to this in one task? E.g. with the Copy task and using zipTree(fooBarWithFile.war) as 'from' and 'war(fooBarWithoutFile.war)' and applying a filter in between?

Or is this the way to go, just with a loop? Delete/Remove file from war with Gradle

Any help is highly appreciated! Cheers, d.

---------UPDATE-------------------

Thanx Lance Java for your solution.

As I mentioned in my comment, I faced the problem that the war files were downloaded/extracted during execution time and hence not accessable to define the new tasks at configuration time.

My workaround for this is to use tarTree (with a filter) to access the list of war-files that are not yet extracted. See my code example below:

def warFileSourceTarGz = '...tar.gz'
def nfsLibDir="$buildDir/dependencies/"
def nfsLibDownloadDir="$buildDir/downloadedDependencies/"

// task that downloads & extracts the tar.gz
task fetchNfsDependencies(type: Copy) {               
    from tarTree(warFileSourceTarGz)
    into nfsLibDownloadDir    
}


// loop through all war files inside the tar.gz and
// create a task to remove unwanted libraries for each war
task excludeUnwantedJarsFromWars(dependsOn: fetchNfsDependencies){

    // access the "remote" tar.gz file to get the list of war-files to loop over
    def warFileSource = tarTree(warFileSourceTarGz).matching{ 
            include '*.war'
    }

    // for every war-file, create an exclude-path    
    warFileSource.visit  { nextWarFile ->

        if(nextWarFile.name.endsWith('.war')) {

            String taskName = "excludeUnwantedJarsFrom_${nextWarFile.name.replace('.war', '')}"
            String nextWarFilePath = nfsLibDownloadDir+"/"+nextWarFile.name 

            Zip tweakWarTask = tasks.create(name: taskName, type: Zip, dependsOn: fetchNfsDependencies) {

                from  zipTree(nextWarFilePath)
                destinationDir = file(nfsLibDir)
                archiveName = nextWarFile.name

                // exclude these jars, as they cause classloading problems in our ear deployment.
                exclude  'WEB-INF/lib/jcan-optrace*'
            }       

            // hook into build-process
            ear.dependsOn(tweakWarTask)
        }   
    }
}

ear.dependsOn(excludeUnwantedJarsFromWars)

Upvotes: 0

Views: 2968

Answers (1)

lance-java
lance-java

Reputation: 27976

I'd create a Zip task per war file and wire all the tasks into the DAG by having assemble depend on them all

FileTree warFiles = fileTree(dir: 'path/to/wars', includes: ['**/*.war'])
warFiles.files.each { File warFile ->
    String taskName = "tweakWar${warFile.name.replace('.war', '')}"
    Zip tweakWarTask = tasks.create(name: taskName, type: Zip) {
        from zipTree(warFile) {
            exclude 'path/to/some/file.xml'
        }
        destinationDir = "$buildDir/tweakedWars"
        archiveName = warFile.name
    }
    // wire the task into the dag
    assemble.dependsOn tweakWarTask 
}

Upvotes: 1

Related Questions