Gradle Re-download ((NEW)) Dependencies
Hedy Gronewald
Generally, you can refresh dependencies in your cache with the command line option --refresh-dependencies. You can also delete the cached files under /.gradle/caches. With the next build Gradle would attempt to download them again.
The --refresh-dependencies option tells Gradle to ignore all cached entries for resolved modules and artifacts. A fresh resolve will be performed against all configured repositories, with dynamic versions recalculated, modules refreshed, and artifacts downloaded. However, where possible Gradle will check if the previously downloaded artifacts are valid before downloading again. This is done by comparing published SHA1 values in the repository with the SHA1 values for existing downloaded artifacts.
The --refresh-dependencies option tells Gradle to ignore all cached entries for resolved modules and artifacts. A fresh resolve will be performed against all configured repositories, with dynamic versions recalculated, modules refreshed, and artifacts downloaded.
You can tell Gradle to re-download some dependencies in the build script by flagging the dependency as 'changing'. Gradle will then check for updates every 24 hours, but this can be configured using the resolutionStrategy DSL. I find it useful to use this for for SNAPSHOT or NIGHTLY builds.
Mb I'm too late however my solution is for single repository. I think deleting /.gradle/* is overkill. The problmem I've bumped into was that I was deleting directory where sources were and gradle was getting another version not from nexus. To avoid that I run the next:
For the majority of cases, just simply re-building the project should do the trick. Sometimes you have to run ./gradlew build --refresh-dependencies as several answers have already mentioned (takes a long time, depending on how much dependencies you have). How ever, sometimes none of those will work: the dependency just won't get updated. Then, you can do this:
You need to redownload it, so you can either manually download and replace the corrupted file and again sync your project . Go to this locationC:\users[username].gradle\wrapper\dist\gradle3.3-all\55gk2rcmfc6p2dg9u9ohc3hw9\gradle-3.3-all.zipHere delete gradle3.3allzip and replace it by downloading again from this site the same file and download and paste it to that locationThen sync your project.Hope it works for you too.
This quick tutorial is going to cover how to refresh or redownload dependencies in Gradle. This is useful when the Gradle Dependency Cache is out of sync with the actual state of the configured repositories.
3. ConclusionThe tutorial has illustrated us how to refresh or redownload dependencies in Gradle by three different ways. And we can see that the first way which forces Gradle to go to the network to re-evaluate and re-fetch all dependency metadata, is the simplest and easiest way.
There are many situations when you want to use the latest version of a particular module dependency, or the latest in a range of versions.This can be a requirement during development, or you may be developing a library that is designed to work with a range of dependency versions.You can easily depend on these constantly changing dependencies by using a dynamic version.A dynamic version can be either a version range (e.g. 2.+) or it can be a placeholder for the latest version available e.g. latest.integration.
Projects might adopt a more aggressive approach for consuming dependencies to modules.For example you might want to always integrate the latest version of a dependency to consume cutting edge features at any given time.A dynamic version allows for resolving the latest version or the latest version of a version range for a given module.
By default, Gradle caches dynamic versions of dependencies for 24 hours. Within this time frame, Gradle does not try to resolve newer versions from the declared repositories.The threshold can be configured as needed for example if you want to resolve new versions earlier.
By default, Gradle caches changing versions of dependencies for 24 hours.Within this time frame, Gradle does not try to resolve newer versions from the declared repositories. The threshold can be configured as needed for example if you want to resolve new snapshot versions earlier.
At times, the Gradle Dependency Cache can become out of sync with the actual state of the configured repositories.Perhaps a repository was initially misconfigured, or perhaps a "non-changing" module was published incorrectly.To refresh all dependencies in the dependency cache, use the --refresh-dependencies option on the command line.
The --refresh-dependencies option tells Gradle to ignore all cached entries for resolved modules and artifacts.A fresh resolve will be performed against all configured repositories, with dynamic versions recalculated, modules refreshed, and artifacts downloaded.However, where possible Gradle will check if the previously downloaded artifacts are valid before downloading again.This is done by comparing published SHA1 values in the repository with the SHA1 values for existing downloaded artifacts.
In other words, refreshing dependencies only has an impact if you actually use dynamic dependencies or that you have changing dependencies that you were not aware of (in which case it is your responsibility to declare them correctly to Gradle as changing dependencies).
The question is how to resolve all dependencies for all modules, for all configurations (the (*) step). We have tried the dependencies task, but this only resolves the compile dependencies. We have also tried the test task with a filter not maching any tests, but Gradle will fail because no tests are run. We have also tried enabling dependency locking, but this made no difference.
Hello, I have changing external dependencies in my project. When building the project I noticed that when the dependency is re-downloaded Gradle signals on command line output that all tasks are up-to-date.
My observation is that after downloading a changed dependency gradle ignores this change. In my case B should have be compiled and failed. But compilation was skipped because it was seen as UP-TO-DATE. The build was successful but should have failed.
The gradle-build-action is the officially supported way to run your Gradle build in GitHub Actions, taking care of preparing and optimizing Gradle for your GitHub Actions workflow. When applied to a workflow, all subsequent Gradle invocations will be optimized, allowing you to simply run ./gradlew build in a regular workflow step.
The Gradle User Home directory persists a lot of valuable state that speeds up subsequent invocations of Gradle. Downloaded dependencies, compiled build scripts, the local Build Cache and generated API jars are all stored in the Gradle User Home.
Each GitHub Actions Job runs on a fresh build runner, meaning it will start with an empty Gradle User Home directory. Fortunately, GitHub Actions provides a caching mechanism that allows the Gradle User Home state to be saved after running one job, and restored before running another. This can greatly reduce the time spent running your Gradle builds, by removing the need to re-download dependencies, re-generate Gradle API jars, etc.
The gradle-build-action takes care of the details for you, saving and restoring the most important files from Gradle User Home in a Job-specific manner, while extracting common files and saving them separately in order to reduce redundancy in the entries stored. Much of the behaviour is configurable and tweakable. Details of the Save/Restore strategy employed by gradle-build-action (and the related configuration options) will be the topic of a future post.
However, by using the gradle-build-action and by configuring each Gradle invocation to publish Build Scans, you can set up your GitHub Actions workflow to provide these usability features you have grown to expect. The gradle-build-action instruments all Gradle build invocations, capturing details such as tasks executed, build outcome and the link to any Build Scan produced. And the linked Gradle Build Scan provides a complete view of a build execution, including all build logs, a complete task timeline, test outputs, dependencies resolved and performance characteristics of your build.
For more details, read about how the Google AndroidX team leverages the gradle-build-action and Gradle Build Scans to help them troubleshoot build and test failures faster in their GitHub Actions CI environment.
We recommend that most projects use the Gradle Wrapper to run Gradle, and by default the gradle-build-action will not download or install a Gradle Distribution. But there are certain situations where you may want to run your build with a different version of Gradle: e.g. you want to smoke test your build with a Gradle release-candidate, or you want to test your Plugin samples with a matrix of different Gradle versions.
The gradle-build-action provides a simple and effective way to run Gradle builds on GitHub Actions, maximizing the use of the GitHub Actions cache and presenting important information about each Gradle execution. When combined with free Gradle Build Scans (or self-hosted Gradle Enterprise Build Scans), running Gradle builds on GitHub Actions is better than ever.
I am currently leveraging caching of gradle dependency files to speed up performance between build/test stages. And while it appears based on logging that thousands of files are cached and restored between build/test, the stages still re-download all of the dependency artifacts anyway based on gradle debug output (-i).
In development, We have many use cases where we have to redownload dependencies.
- when you are doing Gradle build the first time, It downloads all dependenciesFor suppose, the build fails and some dependencies are not downloaded due to network issues.
- Sometimes, the dependency version has been changed, and You have to re-download the new version