Skip to content

Commit

Permalink
Merge 8e67701 into 3959e1c
Browse files Browse the repository at this point in the history
  • Loading branch information
@OdysseusLives
OdysseusLives committed Dec 13, 2019
2 parents 3959e1c + 8e67701 commit 5446466
Show file tree
Hide file tree
Showing 2 changed files with 190 additions and 97 deletions.
230 changes: 133 additions & 97 deletions src/main/groovy/nebula/plugin/dependencylock/DependencyLockTaskConfigurer.groovy
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,7 @@ import nebula.plugin.dependencylock.tasks.UpdateLockTask
import nebula.plugin.scm.ScmPlugin
import org.gradle.api.GradleException
import org.gradle.api.Project
import org.gradle.api.UnknownTaskException
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.Dependency
import org.gradle.api.logging.Logger
Expand All @@ -44,13 +45,17 @@ class DependencyLockTaskConfigurer {

public static final String OVERRIDE_FILE = 'dependencyLock.overrideFile'
public static final String GLOBAL_LOCK_CONFIG = '_global_'

public static final String GENERATE_GLOBAL_LOCK_TASK_NAME = 'generateGlobalLock'
public static final String UPDATE_GLOBAL_LOCK_TASK_NAME = 'updateGlobalLock'
public static final String UPDATE_LOCK_TASK_NAME = 'updateLock'
public static final String GENERATE_LOCK_TASK_NAME = 'generateLock'
public static final String MIGRATE_LOCKED_DEPS_TO_CORE_LOCKS_TASK_NAME = "migrateLockeDepsToCoreLocks"
public static final String MIGRATE_TO_CORE_LOCKS_TASK_NAME = "migrateToCoreLocks"
public static final String DIFF_LOCK_TASK_NAME = 'diffLock'
public static final String COMMIT_LOCK_TASK_NAME = 'commitLock'
public static final String SAVE_LOCK_TASK_NAME = 'saveLock'
public static final String SAVE_GLOBAL_LOCK_TASK_NAME = 'saveGlobalLock'

final Set<String> configurationsToSkipForGlobalLock = ['checkstyle', 'findbugs', 'findbugsPlugins', 'jacocoAgent', 'jacocoAnt']

Expand All @@ -72,15 +77,15 @@ class DependencyLockTaskConfigurer {
UpdateLockTask updateLockTask = project.tasks.create(UPDATE_LOCK_TASK_NAME, UpdateLockTask)
configureGenerateLockTask(updateLockTask, lockFilename, extension, overrides)

SaveLockTask saveTask = configureSaveTask(lockFilename, genLockTask, updateLockTask, extension)
TaskProvider<SaveLockTask> saveTask = configureSaveTask(lockFilename, genLockTask, updateLockTask, extension)
createDeleteLock(saveTask)

configureMigrateToCoreLocksTask(extension)

TaskProvider<DiffLockTask> diffLockTask = configureDiffLockTask(lockFilename, extension)

// configure global lock only on rootProject
SaveLockTask globalSave = null
TaskProvider<SaveLockTask> globalSave = null
GenerateLockTask globalLockTask
UpdateLockTask globalUpdateLock
if (project == project.rootProject) {
Expand All @@ -100,102 +105,119 @@ class DependencyLockTaskConfigurer {
lockFilename
}

private void configureCommitTask(String clLockFileName, String globalLockFileName, SaveLockTask saveTask, DependencyLockExtension lockExtension,
DependencyLockCommitExtension commitExtension, SaveLockTask globalSaveTask = null) {
private void configureCommitTask(String clLockFileName, String globalLockFileName, TaskProvider<SaveLockTask> saveTask, DependencyLockExtension lockExtension,
DependencyLockCommitExtension commitExtension, TaskProvider<SaveLockTask> globalSaveTask = null) {
project.plugins.withType(ScmPlugin) {
if (!project.rootProject.tasks.findByName('commitLock')) {
CommitLockTask commitTask = project.rootProject.tasks.create('commitLock', CommitLockTask)
commitTask.mustRunAfter(saveTask)
if (globalSaveTask) {
commitTask.mustRunAfter(globalSaveTask)
}
commitTask.conventionMapping.with {
scmFactory = { project.rootProject.scmFactory }
commitMessage = {
project.hasProperty('commitDependencyLock.message') ?
project['commitDependencyLock.message'] : commitExtension.message
def hasCommitLockTask = false
try {
project.rootProject.tasks.named(COMMIT_LOCK_TASK_NAME)
hasCommitLockTask = true // if there is not an exception, then the task exists
} catch (UnknownTaskException ute) {
LOGGER.debug("Task $COMMIT_LOCK_TASK_NAME is not in the root project.", ute.getMessage())
}
if (!hasCommitLockTask) {
TaskProvider<CommitLockTask> commitTask = project.rootProject.tasks.register(COMMIT_LOCK_TASK_NAME, CommitLockTask)
commitTask.configure {
it.mustRunAfter(saveTask)
if (globalSaveTask) {
it.mustRunAfter(globalSaveTask)
}
patternsToCommit = {
List<File> lockFiles = []
def rootLock = new File(project.rootProject.projectDir, clLockFileName ?: lockExtension.lockFile)
if (rootLock.exists()) {
lockFiles << rootLock
it.conventionMapping.with {
scmFactory = { project.rootProject.scmFactory }
commitMessage = {
project.hasProperty('commitDependencyLock.message') ?
project['commitDependencyLock.message'] : commitExtension.message
}
def globalLock = new File(project.rootProject.projectDir, globalLockFileName ?: lockExtension.globalLockFile)
if (globalLock.exists()) {
lockFiles << globalLock
}
project.rootProject.subprojects.each {
def potentialLock = new File(it.projectDir, clLockFileName ?: lockExtension.lockFile)
if (potentialLock.exists()) {
lockFiles << potentialLock
patternsToCommit = {
List<File> lockFiles = []
def rootLock = new File(project.rootProject.projectDir, clLockFileName ?: lockExtension.lockFile)
if (rootLock.exists()) {
lockFiles << rootLock
}
def globalLock = new File(project.rootProject.projectDir, globalLockFileName ?: lockExtension.globalLockFile)
if (globalLock.exists()) {
lockFiles << globalLock
}
project.rootProject.subprojects.each {
def potentialLock = new File(it.projectDir, clLockFileName ?: lockExtension.lockFile)
if (potentialLock.exists()) {
lockFiles << potentialLock
}
}
def patterns = lockFiles.collect {
project.rootProject.projectDir.toURI().relativize(it.toURI()).path
}
LOGGER.info(patterns.toString())
patterns
}
def patterns = lockFiles.collect {
project.rootProject.projectDir.toURI().relativize(it.toURI()).path
shouldCreateTag = {
project.hasProperty('commitDependencyLock.tag') ?: commitExtension.shouldCreateTag
}
LOGGER.info(patterns.toString())
patterns
}
shouldCreateTag = {
project.hasProperty('commitDependencyLock.tag') ?: commitExtension.shouldCreateTag
}
tag = {
project.hasProperty('commitDependencyLock.tag') ? project['commitDependencyLock.tag'] : commitExtension.tag.call()
tag = {
project.hasProperty('commitDependencyLock.tag') ? project['commitDependencyLock.tag'] : commitExtension.tag.call()
}
remoteRetries = { commitExtension.remoteRetries }
}
remoteRetries = { commitExtension.remoteRetries }
}
}
}
}

private SaveLockTask configureSaveTask(String lockFileName, GenerateLockTask lockTask, UpdateLockTask updateTask, DependencyLockExtension extension) {
SaveLockTask saveTask = project.tasks.create('saveLock', SaveLockTask)
saveTask.doFirst {
SaveLockTask globalSave = project.rootProject.tasks.findByName('saveGlobalLock') as SaveLockTask
if (globalSave?.outputLock?.exists()) {
throw new GradleException('Cannot save individual locks when global lock is in place, run deleteGlobalLock task')
private TaskProvider<SaveLockTask> configureSaveTask(String lockFileName, GenerateLockTask lockTask, UpdateLockTask updateTask, DependencyLockExtension extension) {
TaskProvider<SaveLockTask> saveLockTask = project.tasks.register(SAVE_LOCK_TASK_NAME, SaveLockTask)

saveLockTask.configure { saveTask ->
saveTask.doFirst {
SaveLockTask globalSave = project.rootProject.tasks.findByName(SAVE_GLOBAL_LOCK_TASK_NAME) as SaveLockTask
if (globalSave?.outputLock?.exists()) {
throw new GradleException('Cannot save individual locks when global lock is in place, run deleteGlobalLock task')
}
}
saveTask.conventionMapping.with {
generatedLock = { lockTask.dependenciesLock }
outputLock = { new File(project.projectDir, lockFileName ?: extension.lockFile) }
}
}
saveTask.conventionMapping.with {
generatedLock = { lockTask.dependenciesLock }
outputLock = { new File(project.projectDir, lockFileName ?: extension.lockFile) }
}
configureCommonSaveTask(saveTask, lockTask, updateTask)
configureCommonSaveTask(saveLockTask, lockTask, updateTask)

saveTask
saveLockTask
}

private static void configureCommonSaveTask(SaveLockTask saveTask, GenerateLockTask lockTask,
private static void configureCommonSaveTask(TaskProvider<SaveLockTask> saveLockTask, GenerateLockTask lockTask,
UpdateLockTask updateTask) {
saveTask.mustRunAfter lockTask, updateTask
saveTask.outputs.upToDateWhen {
if (saveTask.generatedLock.exists() && saveTask.outputLock.exists()) {
saveTask.generatedLock.text == saveTask.outputLock.text
} else {
false
saveLockTask.configure { saveTask ->
saveTask.mustRunAfter lockTask, updateTask
saveTask.outputs.upToDateWhen {
if (saveTask.generatedLock.exists() && saveTask.outputLock.exists()) {
saveTask.generatedLock.text == saveTask.outputLock.text
} else {
false
}
}
}
}

private SaveLockTask configureGlobalSaveTask(String globalLockFileName, GenerateLockTask globalLockTask,
UpdateLockTask globalUpdateLockTask, DependencyLockExtension extension) {
SaveLockTask globalSaveTask = project.tasks.create('saveGlobalLock', SaveLockTask)
globalSaveTask.doFirst {
project.subprojects.each { Project sub ->
SaveLockTask save = sub.tasks.findByName('saveLock') as SaveLockTask
if (save && save.outputLock?.exists()) {
throw new GradleException('Cannot save global lock, one or more individual locks are in place, run deleteLock task')
private TaskProvider<SaveLockTask> configureGlobalSaveTask(String globalLockFileName, GenerateLockTask globalLockTask,
UpdateLockTask globalUpdateLockTask, DependencyLockExtension extension) {
TaskProvider<SaveLockTask> globalSaveLockTask = project.tasks.register(SAVE_GLOBAL_LOCK_TASK_NAME, SaveLockTask)

globalSaveLockTask.configure { globalSaveTask ->
globalSaveTask.doFirst {
project.subprojects.each { Project sub ->
SaveLockTask save = sub.tasks.findByName(SAVE_LOCK_TASK_NAME) as SaveLockTask
if (save && save.outputLock?.exists()) {
throw new GradleException('Cannot save global lock, one or more individual locks are in place, run deleteLock task')
}
}
}
globalSaveTask.conventionMapping.with {
generatedLock = { globalLockTask.dependenciesLock }
outputLock = { new File(project.projectDir, globalLockFileName ?: extension.globalLockFile) }
}
}
globalSaveTask.conventionMapping.with {
generatedLock = { globalLockTask.dependenciesLock }
outputLock = { new File(project.projectDir, globalLockFileName ?: extension.globalLockFile) }
}
configureCommonSaveTask(globalSaveTask, globalLockTask, globalUpdateLockTask)
configureCommonSaveTask(globalSaveLockTask, globalLockTask, globalUpdateLockTask)

globalSaveTask
globalSaveLockTask
}

private GenerateLockTask configureGenerateLockTask(GenerateLockTask lockTask, String clLockFileName, DependencyLockExtension extension, Map overrides) {
Expand Down Expand Up @@ -240,11 +262,11 @@ class DependencyLockTaskConfigurer {

configurations
.findAll { configuration ->
!configurationsToSkipForGlobalLock.contains(configuration.name)
}
.collect { configuration ->
project.dependencies.create(project.dependencies.project(path: subproject.path, configuration: configuration.name))
}
!configurationsToSkipForGlobalLock.contains(configuration.name)
}
.collect { configuration ->
project.dependencies.create(project.dependencies.project(path: subproject.path, configuration: configuration.name))
}
} else {
[project.dependencies.create(subproject)]
}
Expand All @@ -260,36 +282,45 @@ class DependencyLockTaskConfigurer {
globalLockTask
}

private MigrateToCoreLocksTask configureMigrateToCoreLocksTask(DependencyLockExtension extension) {
def migrateLockedDepsToCoreLocksTask = project.tasks.create(MIGRATE_LOCKED_DEPS_TO_CORE_LOCKS_TASK_NAME, MigrateLockedDepsToCoreLocksTask)
def migrateToCoreLocksTask = project.tasks.create(MIGRATE_TO_CORE_LOCKS_TASK_NAME, MigrateToCoreLocksTask)
private TaskProvider<MigrateToCoreLocksTask> configureMigrateToCoreLocksTask(DependencyLockExtension extension) {
def migrateLockedDepsToCoreLocksTask = project.tasks.register(MIGRATE_LOCKED_DEPS_TO_CORE_LOCKS_TASK_NAME, MigrateLockedDepsToCoreLocksTask)
def migrateToCoreLocksTask = project.tasks.register(MIGRATE_TO_CORE_LOCKS_TASK_NAME, MigrateToCoreLocksTask)
def lockFile = new File(project.projectDir, extension.lockFile)
def dependencyLockDirectory = new File(project.projectDir, "/gradle/dependency-locks")

migrateLockedDepsToCoreLocksTask.conventionMapping.with {
configurationNames = { extension.configurationNames }
inputLockFile = { lockFile }
outputLocksDirectory = { dependencyLockDirectory }
migrateLockedDepsToCoreLocksTask.configure {
it.conventionMapping.with {
configurationNames = { extension.configurationNames }
inputLockFile = { lockFile }
outputLocksDirectory = { dependencyLockDirectory }
}
}

migrateToCoreLocksTask.conventionMapping.with {
configurationNames = { extension.configurationNames }
outputLocksDirectory = { dependencyLockDirectory }

migrateToCoreLocksTask.configure {
it.conventionMapping.with {
configurationNames = { extension.configurationNames }
outputLocksDirectory = { dependencyLockDirectory }
}
it.dependsOn project.tasks.named(MIGRATE_LOCKED_DEPS_TO_CORE_LOCKS_TASK_NAME)
}

migrateToCoreLocksTask.dependsOn(migrateLockedDepsToCoreLocksTask)
migrateToCoreLocksTask
}

private void createDeleteLock(SaveLockTask saveLock) {
project.tasks.create('deleteLock', Delete) {
delete saveLock.outputLock
private void createDeleteLock(TaskProvider<SaveLockTask> saveLock) {
TaskProvider<Delete> deleteLockTask = project.tasks.register('deleteLock', Delete)

deleteLockTask.configure { it ->
it.delete saveLock.map { it.outputLock }
}

}

private void createDeleteGlobalLock(SaveLockTask saveGlobalLock) {
project.tasks.create('deleteGlobalLock', Delete) {
delete saveGlobalLock.outputLock
private void createDeleteGlobalLock(TaskProvider<SaveLockTask> saveGlobalLock) {
TaskProvider<Delete> deleteGlobalLockTask = project.tasks.register('deleteGlobalLock', Delete)

deleteGlobalLockTask.configure { it ->
it.delete saveGlobalLock.map { it.outputLock }
}
}

Expand All @@ -303,7 +334,9 @@ class DependencyLockTaskConfigurer {
}

private TaskProvider<DiffLockTask> configureDiffLockTask(String lockFileName, DependencyLockExtension extension) {
TaskProvider<DiffLockTask> diffLockTask = project.tasks.register(DIFF_LOCK_TASK_NAME, DiffLockTask) { diffTask ->
TaskProvider<DiffLockTask> diffLockTask = project.tasks.register(DIFF_LOCK_TASK_NAME, DiffLockTask)

diffLockTask.configure { diffTask ->
diffTask.mustRunAfter(project.tasks.named(GENERATE_LOCK_TASK_NAME), project.tasks.named(UPDATE_LOCK_TASK_NAME))
def existing = new File(project.projectDir, lockFileName ?: extension.lockFile)
if (existing.exists()) {
Expand All @@ -312,8 +345,11 @@ class DependencyLockTaskConfigurer {
diffTask.updatedLockFile = new File(project.buildDir, lockFileName ?: extension.lockFile)
}

project.tasks.named('saveLock').configure { save ->
project.tasks.named(SAVE_LOCK_TASK_NAME).configure { save ->
save.mustRunAfter(diffLockTask)
}

diffLockTask
}

}

0 comments on commit 5446466

Please sign in to comment.