I’m getting the following error whenever I attempt to use a Copy task to copy a file into the root of a project (the same folder I’m running gradle from):
Failed to create MD5 hash for file content.
I thought this was related to the artifacts I was pulling from Artifactory, but that seems to be unrelated. I was able to get the same results with a minimal script.
Is there something obviously wrong with what I’m doing, or does Gradle intentionally disallow such things?
task fails(type:Copy) {
from 'build/someFile.txt'
into new File('.').absolutePath
}
task works(type:Copy) {
from 'build/someFile.txt'
into new File('.').absolutePath + '/output'
}
Short Answer: Don't copy into the project directory, you are best to use into "$buildDir/someFolder" so that the folder is isolated to this single task, and also so that it will be cleaned by gradle clean
Long Answer: At it's core, Gradle has the concept of an "UP-TO-DATE" check for every single task. If Gradle sees that nothing has changed since last time a task was executed it will use the old result instead of executing again.
UP-TO-DATE checking is implemented by taking a "hash" of the task inputs and task outputs. Since you are using into '.' that means that the entire contents of the project directory is considered a task output (bad)
Gradle uses the .gradle folder for temp files (eg task hashes) It's likely some of these files are locked for writing as Gradle is trying to also read the same files (to calculate the "hash" of the task outputs) causing the error you are seeing
* EDIT *
If you need to copy into the project directory for legacy reasons, you might use Project.copy(...) directly instead of a Copy task. You could manually manage the task inputs/outputs in this case
Eg
task customCopy {
inputs.file "$buildDir/someFile.txt"
outputs.file 'someFile.txt'
doLast {
copy {
from "$buildDir/someFile.txt"
into '.'
}
}
}
Can you believe it, the following works
task myCopy(type: Copy) {
from "$rootDir/app1/src/main/resources/db"
into "$rootDir/app2/src/test/resources/db"
}
test.dependsOn myCopy
and the following doesn't 🤦
task myCopy(type: Copy) {
from '$rootDir/app1/src/main/resources'
into '$rootDir/app2/src/test/resources'
}
test.dependsOn myCopy
Related
I am trying to do something like this:
jar {
doLast{
from "build/libs/TheJar.jar"
into "."
}
}
So far, I have tried various tutorials including all forms from this answer but non have worked. The only thing that works is calling a separate task but I'd like to know why my construction is wrong and why can't I run something after the jar or shadowJar tasks.
It looks like you took some parts of the answers in the linked post and somehow mixed them without knowing what your final code actually does.
Tasks in Gradle may have a type (e.g. Copy, Jar, ...). This type defines what the task will do once it gets executed (so called task actions). A task without a type won't do anything when its executed, unless you add task actions manually. Using doFirst will add the passed action (also called closure) to the start of the list of task actions, using doLast will add it to the end of the list.
Everything outside of doFirst and doLast closures is not part of the execution of the task, but can be used to configure the task:
task example {
doLast {
println "second action"
}
doFirst {
println "first action"
}
println "configuration"
}
Run the code above with gradle example and you will see the order of the log messages as configuration, first action, second action.
Task configuration will run, even if the task won't be executed later on. Even if you call gradle (without any task names as arguments), the console will still print configuration. This was the actual problem in the linked question.
Lets come to the real question: How to copy a file?
Well, Gradle offers two ways to copy a file. The first one is the task type Copy. You can create a task based on this type, apply your configuration and then either call it directly from the command line or define task dependencies using dependsOn or finalizedBy:
task copySomeFiles(type: Copy) {
from '...'
into '...'
}
However, you don't want to create an additional task. Gradle also has a method called copy that may be called anywhere in your script and will instantly copy the files:
copy {
from '...'
into '...'
}
The code above will copy your files, but it will copy your files every time Gradle executes (which may be often, e.g. when using an IDE). To solve this problem, you may move your code with copy to a task action, e.g. inside a doFirst or doLast closure:
jar {
doLast {
copy {
from "build/libs/TheJar.jar"
into "."
}
}
}
As you can see, your code was missing the copy statement. Now, whenever your task jar gets executed, its last task action will copy the files as intended.
Bonus question: Why is there no error?
The "problem" in your case is that your code is perfectly valid Gradle code. The task jar is of type Jar. Every task of type Jar may be configured using methods called from and into. The method from adds files to the JAR file and the method into sets the destination directory inside the JAR. So instead of copying, your code configures the underlying task jar. However, this has no negative consequences, as this configuration gets applied inside doLast, which only runs once the JAR file has already been created. Something that already happened cannot be configured.
I've a simple task in Gradle:
task cleanBuild(type: Delete) {
def build = ".src/buildfiles"
FileTree tree = fileTree (dir: dbEditorBuild);
tree.each { File file ->
println file
}
}
When I run it, I get this output:
:user:cleanBuild UP-TO-DATE
BUILD SUCCESSFUL
Total time: 1.656 secs
I've read the docs and it says that tasks results are cached for performance. I wanted to rerun the task, but I couldn't. And that was despite editing the task code. So, apparently, it seems that Gradle is not able to detect that the task has been changed, which kind of suck.
I've tried what others recommended, like adding this line to the task:
outputs.upToDateWhen { false }
But it doesn't have any effect.
You define a task of the type Delete, but you don't define any files to delete. That is the reason, why your task is always up-to-date, since it has nothing to do. You can define which files will be deleted via the delete method. Everything you pass to this method will be evaluated via Project.files(...):
task myDelete(type: Delete) {
delete 'path/to/file', 'path/to/other/file'
}
Please note, that your code example does not interfere with the up-to-date checks, it doesn't even interfere with the task at all. Since you are not using a doFirst/doLast closure, you are using the configuration closure of the task, which is executed during configuration phase. Since you are also not using any task methods, your code would mean absolutely the same if it would be placed outside of the task configuration closure.
As a small addition: Even if this specific problem is not caused by the Gradle up-to-date checks, there is a way to force Gradle to execute all tasks ignoring any task optimization: Simply add --rerun-tasks as command line argument, as described in the docs.
If you are trying to delete some additional files that are not deleted with a default clean task (because it deletes only the build directories) you can extend the clean task to delete other things as well.
clean {
delete += "$buildDir"
delete += "$rootDir/someDir/someClass.java"
delete += "$rootDir/otherDir
}
Or create a new task to delete files and dependOn it to put in the build lifecycle.
task deleteSomething(type: Delete) {
// to delete a file
delete 'uglyFolder', 'uglyFile'
// to delete a directory
delete 'uglyFolder'
followSymlinks = true
}
Be default symlinks will not be followed when deleting files. To change this behavior call Delete.setFollowSymlinks(boolean) with true. On systems that do not support symlinks, this will have no effect.
Or you can put the action into the execution phase, and delete it.
task cleanBuild {
def build = new File("$rootDir/src/buildfiles")
doLast{
build.deleteDir()
}
}
Also, be sure the task has something to do because if the task has nothing to do, there is nothing to delete etc it will print UP-TO-DATE #lu.koerfer answer explains it perfectly.
I'm using Gradle to create a build script. I want to protect the script from wrong properties, one of the tasks in the script is simple Copy task and I notice that when I put non-exist directory as from parameter the task continue with Skipping task ':copySpecificPlatform' as it has no source files.
Is there a way to cause the copy task to fail in this case?
This worked for me:
task copySpecificPlatform(type: Copy) {
from 'source/directory'
into 'target/directory'
if(inputs.sourceFiles.empty) throw new StopExecutionException("No files found")
}
You can try:
task cp(type: Copy) {
from 'empty'
into 'target'
inputs.sourceFiles.stopExecutionIfEmpty()
}
Every Task has its TaskInputs which source files are a FileCollection that has special method which configures the desired behavior.
I am trying to use the zip in gradle and my build worked fine until I added this to my section for the "webserver" project (maybe my question should be why does the copy work without task in front of it?????...I am just really confused by the difference between copy and zip if you need task in front of zip but not copy below)
assemble << {
zip {
from '.'
includes ['app/*','conf/*','public/*','play-1.2.4/*','run*.sh']
}
}
The error is
What went wrong:
Execution failed for task ':webserver:assemble'.
Could not find method zip() for arguments [build_3nljqgmljp29v06751h102sq8b$_run_closure3_closure16_closure18#7cc8e407] on task ':webserver:assemble'.
I don't understand as I am using copy successfully like so
copy { from fixedLibDir into genLibDir }
Also, I am getting really really confused by the documentation as in the documentation, they almost always have
task myZip(type: Zip) {
}
I just want to call a zip task not create a new one every time, so the documentation examples seem to be very bad...they should be examples of using zip task not creating a new one(after all, who wants to create a new zip task when one already exists??) OR am I missing something here? At any rate, that confused me when getting started with gradle alot and I am guessing it will confuse others. It might be nice to show both using it and defining a new one(though I still don't get why I would define a new one).
MORE INFO/UPDATE:
I also tried this code which runs and I see the print out message but I see no zip file in my webserver/output/libs directory as I would expect???
assemble << {
println "I'm zipping up now"
task zip(type: Zip) {
from('.') {
fileMode = 0755
include 'run*.sh'
include 'app/*'
}
}
}
later,
Dean
The reason copy works, is because it's a global utility function defined in Project (see here). So you can call copy from anywhere, and it will work.
On the other hand there is no equivalent zip method. Perhaps, because zipping usually need more configuration than copying, like specifying zip archive name, or maybe they just missed it out. This means that you have to use the task zip(type: Zip){ from ... into ... } syntax for zip.
In contrast to Copy, copy is not a task; it is just a method on the Project class. Gradle doesn't have any information about, and doesn't control the execution of, methods like it does for tasks. Therefore, methods have some drawbacks over the corresponding tasks (e.g. no up-to-date check) and should only be used when a task is not an option (which is less often than you think).
As for zip, there is simply no such method, in particular not on the Project class. The best place to look up such information is the Gradle DSL reference.
after all, who wants to create a new zip task when one already exists
Not sure what you mean by that; maybe you are confusing tasks and task types. It's perfectly normal to use a separate task for every zip file to be created.
PS: I recommend to take a step back and learn more about Gradle before tackling real-world builds.
I think the correct way to do this now is
task myZip(type: Zip) {
from('.') {
include 'run*.sh'
include 'app/*'
}
}
assemble.dependsOn('myZip')
//This last line is important of course!!!!
I am not sure what the following does to be honest now as it doesn't do anything except println
assemble << {
println "I'm zipping up now"
task zip(type: Zip) {
from('.') {
fileMode = 0755
include 'run*.sh'
include 'app/*'
}
}
}
I'm adding a task to deploy war files to Tomcat .. the only thing that the task needs to do is copy the war file to the TOMCAT location.
There 2 ways that I can think of implementing this .. but being new to gradle, I'm not quite sure what's more conventional/right (or if it even matters).
task myCopy(type: Copy)
myCopy.configure {
from('source')
into('target')
include('*.war')
}
or
task myCopy{
doLast{
copy {
from 'source'
into 'target'
include '*.war'
}
}
}
In most cases (including this one), the Copy task is the better choice. Among other things, it will give you automatic up-to-date checking. The copy method is meant for situations where (for some reason) you have to bolt on to an existing task and cannot use a separate task for copying.
The code for your Copy task can be simplified to:
task myCopy(type: Copy) {
from('source')
into('target')
include('*.war')
}
UP-TO-DATE only verifies the file is in place but not if the files has changed
to avoid being cached with an old file use
outputs.upToDateWhen { false }