Merge pull request #176 from Cognifide/develop

Release 4.0.0-beta2

Author: pun-ky

README.md

@@ -109,19 +109,29 @@ so that this repository need to be included in *buildscript* section.
 
 #### Minimal:
 
+File *settings.gradle*:
 ```groovy
-buildscript {
-    repositories {
-        jcenter()
-        maven { url  "http://dl.bintray.com/cognifide/maven-public" }
-    }
-    
-    dependencies {
-        classpath 'com.cognifide.gradle:aem-plugin:4.0.0-beta'
-    }
+pluginManagement {
+	repositories {
+		jcenter()
+		maven { url  "http://dl.bintray.com/cognifide/maven-public" }
+	}
+	resolutionStrategy {
+		eachPlugin {
+			if (requested.id.namespace == 'com.cognifide.aem') {
+				useModule('com.cognifide.gradle:aem-plugin:4.0.0-beta2')
+			}
+		}
+	}
 }
+```
 
-apply plugin: 'com.cognifide.aem.package'
+File *build.gradle*:
+```groovy
+plugins {
+	id 'com.cognifide.aem.bundle' // or 'package' for JCR content only
+	
+}
 ```
 
 Building and deploying to AEM via command: `gradlew aemDeploy`.
@@ -131,8 +141,11 @@ Building and deploying to AEM via command: `gradlew aemDeploy`.
 AEM configuration section contains all default values for demonstrative purpose.
 
 ```groovy
-apply plugin: 'com.cognifide.aem.instance'
-apply plugin: 'kotlin' // 'java' or whatever you like to compile bundle
+plugins {
+	id 'com.cognifide.aem.bundle'
+	id 'com.cognifide.aem.instance'
+	id 'org.jetbrains.kotlin.jvm' // or any other like 'java' to compile OSGi bundle
+}
 
 defaultTasks = [':aemSatisfy', ':aemDeploy', ':aemAwait']
 
@@ -481,20 +494,32 @@ Upload & install dependent CRX package(s) before deployment. Available methods:
 * `downloadSftpAuth(url: String, username: String, password: String)`, download package using SFTP protocol.
 * `downloadSftpAuth(url: String)`, as above, but credentials must be specified in variables: `aem.sftp.username`, `aem.sftp.password`. Optionally enable strict host checking by setting property `aem.sftp.hostChecking` to `true`.
 * `dependency(notation: String)`, use OSGi bundle that will be resolved from defined repositories (for instance from Maven) then wrapped to CRX package: `dependency('com.neva.felix:search-webconsole-plugin:1.2.0')`.
-* `group(name: String, configurer: Closure)`, useful for declaring group of packages (or just naming single package) to be installed only on demand. For instance: `group 'tools', { url('http://example.com/package.zip'); url('smb://internal-nt/package2.zip')  }`. Then to install only packages in group `tools`, use command: `gradlew aemSatisfy -Paem.satisfy.group=tools`.
+* `group(name: String, configurer: Closure)`, useful for declaring group of packages (or just optionally naming single package) to be installed only on demand. For instance: `group 'tools', { url('http://example.com/package.zip'); url('smb://internal-nt/package2.zip')  }`. Then to install only packages in group `tools`, use command: `gradlew aemSatisfy -Paem.satisfy.group=tools`.
+
+It is also possible to specify packages to be deployed only once via command line parameter. Also for local files at any file system paths.
+
+```bash
+gradlew aemSatisfy -Paem.satisfy.urls=[url1,url2]
+```
+
+For instance:
+
+```bash
+gradlew aemSatisfy -Paem.satisfy.urls=[https://github.com/OlsonDigital/aem-groovy-console/releases/download/11.0.0/aem-groovy-console-11.0.0.zip,https://github.com/neva-dev/felix-search-webconsole-plugin/releases/download/search-webconsole-plugin-1.2.0/search-webconsole-plugin-1.2.0.jar]
+```
 
 #### Task `aemAwait`
 
 Wait until all local or remote AEM instance(s) be stable.
 
 AEM Config Param | CMD Property | Default Value | Purpose
 --- | --- | --- | ---
-`awaitStableInterval` | *aem.await.interval* | `1000` | Time in milliseconds used as interval between next instance stability checks being performed. Optimization could be necessary only when instance is heavily loaded.
+`awaitStableInterval` | *aem.await.stable.interval* | `1000` | Time in milliseconds used as interval between next instance stability checks being performed. Optimization could be necessary only when instance is heavily loaded.
 `awaitStableTimeout` | *aem.await.stable.timeout* | `900` | After each await interval, instance stability check is being performed. This value is a HTTP connection timeout (in millis) which must be smaller than interval to avoid race condition.
 `awaitStableTimes` | *aem.await.stable.times* | `300` | Maximum intervals after which instance stability checks will be skipped if there is still some unstable instance left.
 `awaitStableAssurances` | *aem.await.stable.assurances* | `3L` | Number of intervals / additional instance stability checks to assure all stable instances.
 `awaitStableCheck` | n/a | `{ it.checkBundleStable(500) }` | Hook for customizing instance stability check. Check will be repeated if assurance is configured. 
-`awaitHealthCheck` | n/a | { `it.checkComponentState(awaitHealthComponentsActive) }` | Hook for customizing instance health check.
+`awaitHealthCheck` | n/a | { `it.checkComponentState(10000) }` | Hook for customizing instance health check.
 `awaitFast` | *aem.await.fast* | `false` | Skip stable check assurances and health checking. Alternative, quicker type of awaiting stable instances.
 `awaitFastDelay` | *aem.await.fast.delay* | `1000` | Time in milliseconds to postpone instance stability checks to avoid race condition related with actual operation being performed on AEM like starting JCR package installation or even creating launchpad.
 `awaitResume` | *aem.await.resume* | `false` | Do not fail build but log warning when there is still some unstable or unhealthy instance.
@@ -558,27 +583,27 @@ allprojects { subproject ->
   plugins.withId 'com.cognifide.aem.base', {
     aem {
         config {
-          localInstance "http://localhost:6502"
+          remoteInstance "http://localhost:6502"
           contentPath = subproject.file("src/main/aem")
         }
     }
   }
 }
 ```
 
-Project `:app` specific configuration like CRX package options should be defined in `app/build.gradle`:
+For instance, project `:app:core` specific configuration like OSGi bundle or CRX package options should be defined in `app/core/build.gradle`:
 
 ```groovy
 aem {
     config {
-        contentPath = project.file("src/main/aem")
+        bundlePackage = 'com.company.aem.example.core'
     }
 }
 
 aemCompose {
-    baseName = 'company-example'
+    includeProjects ':content:*'
+    baseName = 'example-core'
     duplicatesStrategy = "EXCLUDE"
-    includeProject ':app:core'
 }
 ```
 
@@ -640,6 +665,17 @@ aem {
 }
 ```
 
+The above configuration can be also specified through *gradle.properties* file using dedicated syntax.
+
+`aem.instance.$TYPE.$ENVIRONMENT-$TYPE_NAME.$PROP_NAME=$PROP_VALUE`
+
+Part | Possible values | Description |
+--- | --- | --- |
+`$TYPE` | `local` or `remote` (only) |  Type of instance. Local means that for each one there will be set up AEM Quickstart at local file system. | 
+`$ENVIRONMENT` | `local`, `int`, `stg` etc | Environment name. |
+`$TYPE_NAME` | `author`, `publish`, `publish2`, etc | Combination of AEM instance type and semantic suffix useful when more than one of instance of same type is being configured. |
+`$PROP_NAME=$PROP_VALUE` | Local instances: `httpUrl=http://admin:admin@localhost:4502`, `password=foo`, `runModes=nosamplecontent`, `jvmOpts=-server -Xmx2048m -XX:MaxPermSize=512M -Djava.awt.headless=true`, `startOpts=...`, `debugPort=24502`. Remote instances: `httpUrl`, `user`, `password`. | Run modes, JVM opts and start opts should be comma delimited. |
+
 **Rules:**
 
 * Instance name is a combination of *${environment}-${typeName}* e.g *local-author*, *integration-publish* etc.

build.gradle

@@ -6,7 +6,7 @@ plugins {
 }
 
 group 'com.cognifide.gradle'
-version '4.0.0-beta'
+version '4.0.0-beta2'
 description = 'Gradle AEM Plugin'
 defaultTasks = ['clean', 'build', 'publishToMavenLocal']
 

src/main/kotlin/com/cognifide/gradle/aem/api/AemConfig.kt

@@ -413,7 +413,7 @@ class AemConfig(
      */
     @Internal
     @get:JsonIgnore
-    var awaitHealthCheck: (InstanceState) -> Boolean = { it.checkComponentState( setOf("com.day.crx.packaging.*", "org.apache.sling.installer.*"), 10000) }
+    var awaitHealthCheck: (InstanceState) -> Boolean = { it.checkComponentState(10000) }
 
     /**
      * Time in milliseconds to postpone instance stability checks after triggering instances restart.

src/main/kotlin/com/cognifide/gradle/aem/api/AemDefaultTask.kt

@@ -14,7 +14,7 @@ abstract class AemDefaultTask : DefaultTask(), AemTask {
     protected val notifier = AemNotifier.of(project)
 
     @Internal
-    protected val propertyParser = PropertyParser(project)
+    protected val props = PropertyParser(project)
 
     init {
         group = AemTask.GROUP

src/main/kotlin/com/cognifide/gradle/aem/instance/CreateTask.kt

@@ -35,12 +35,12 @@ open class CreateTask : AemDefaultTask() {
     }
 
     private fun instanceFilesByProperties() {
-        val jarUrl = propertyParser.string(JAR_URL_PROP)
+        val jarUrl = props.string(JAR_URL_PROP)
         if (!jarUrl.isNullOrBlank()) {
             instanceFileResolver.url(jarUrl!!)
         }
 
-        val licenseUrl = propertyParser.string(LICENSE_URL_PROP)
+        val licenseUrl = props.string(LICENSE_URL_PROP)
         if (!licenseUrl.isNullOrBlank()) {
             instanceFileResolver.url(licenseUrl!!)
         }

src/main/kotlin/com/cognifide/gradle/aem/instance/DestroyTask.kt

@@ -15,7 +15,7 @@ open class DestroyTask : AemDefaultTask() {
 
     @TaskAction
     fun destroy() {
-        propertyParser.checkForce()
+        props.checkForce()
 
         val handles = Instance.handles(project)
         handles.parallelStream().forEach { it.destroy() }

src/main/kotlin/com/cognifide/gradle/aem/instance/InstanceState.kt

@@ -45,6 +45,10 @@ class InstanceState(private var _sync: InstanceSync, val instance: Instance) {
         })
     }
 
+    fun checkComponentState(connectionTimeout: Int = 10000): Boolean {
+        return checkComponentState(PLATFORM_COMPONENTS, connectionTimeout)
+    }
+
     fun checkComponentState(packagesActive: Collection<String>, connectionTimeout: Int = 10000): Boolean {
         return check({
             it.connectionTimeout = connectionTimeout
@@ -74,4 +78,11 @@ class InstanceState(private var _sync: InstanceSync, val instance: Instance) {
                 .isEquals
     }
 
+    companion object {
+        val PLATFORM_COMPONENTS = setOf(
+                "com.day.crx.packaging.*",
+                "org.apache.sling.installer.*"
+        )
+    }
+
 }

src/main/kotlin/com/cognifide/gradle/aem/instance/SatisfyTask.kt

@@ -32,20 +32,39 @@ open class SatisfyTask : AemDefaultTask() {
 
     @get:Internal
     val packageGroups by lazy {
-        logger.info("Providing packages from local and remote sources.")
+        val result = if (cmdGroups) {
+            logger.info("Providing packages defined via command line.")
+            packageProvider.filterGroups("cmd.*")
+        } else {
+            logger.info("Providing packages defined in build script.")
+            packageProvider.filterGroups(groupFilter)
+        }
 
-        val packageGroups = packageProvider.filterGroups(groupFilter)
-        val packageFiles = packageGroups.flatMap { it.files }
+        val files = result.flatMap { it.files }
 
-        logger.info("Packages provided (${packageFiles.size}).")
+        logger.info("Packages provided (${files.size}).")
 
         @Suppress("unchecked_cast")
-        packageGroups as List<PackageGroup>
+        result as List<PackageGroup>
     }
 
+    @get:Internal
+    val cmdGroups: Boolean
+        get() = project.properties["aem.satisfy.urls"] != null
+
     init {
         group = AemTask.GROUP
         description = "Satisfies AEM by uploading & installing dependent packages on instance(s)."
+
+        defineCmdGroups()
+    }
+
+    fun defineCmdGroups() {
+        if (cmdGroups) {
+            props.list("aem.satisfy.urls").forEachIndexed { index, url ->
+                packageProvider.group("cmd.${index + 1}", { url(url) })
+            }
+        }
     }
 
     fun packages(closure: Closure<*>) {

src/main/kotlin/com/cognifide/gradle/aem/internal/PropertyParser.kt

@@ -45,15 +45,21 @@ class PropertyParser(val project: Project) {
     }
 
     private fun prop(name: String): String? {
-        var value = project.properties[name] as String?
-        if (value == null) {
-            value = systemProps[name]
+        if (project.hasProperty(name)) {
+            return project.property(name).toString()
         }
-        if (value == null) {
-            value = envProps[name]
+
+        var systemValue = System.getProperty(name)
+        if (systemValue != null) {
+            return systemValue
+        }
+
+        var envValue = System.getenv(name)
+        if (envValue != null) {
+            return envValue
         }
 
-        return value
+        return null
     }
 
     fun flag(name: String): Boolean {

src/main/kotlin/com/cognifide/gradle/aem/internal/file/resolver/FileResolver.kt

@@ -1,6 +1,8 @@
 package com.cognifide.gradle.aem.internal.file.resolver
 
 import com.cognifide.gradle.aem.internal.Formats
+import com.cognifide.gradle.aem.internal.Patterns
+import com.cognifide.gradle.aem.internal.file.FileException
 import com.cognifide.gradle.aem.internal.file.downloader.HttpFileDownloader
 import com.cognifide.gradle.aem.internal.file.downloader.SftpFileDownloader
 import com.cognifide.gradle.aem.internal.file.downloader.SmbFileDownloader
@@ -68,13 +70,21 @@ open class FileResolver(val project: Project, val downloadDir: File) {
         return filterGroups(filter).flatMap { it.files }
     }
 
+    fun group(name: String): FileGroup {
+        return groups.find { it.name == name } ?: throw FileException("File group '$name' is not defined.")
+    }
+
+    fun filterGroups(filter: String): List<FileGroup> {
+        return filterGroups { Patterns.wildcard(it, filter) }
+    }
+
     fun filterGroups(filter: (String) -> Boolean): List<FileGroup> {
         return groups.filter { filter(it.name) }.filter { it.resolutions.isNotEmpty() }
     }
 
     fun dependency(notation: Any) {
         resolve(notation, {
-            val configName = "fileResolver_dependency_${DigestUtils.md5Hex(downloadDir.path +  notation)}"
+            val configName = "fileResolver_dependency_${DigestUtils.md5Hex(downloadDir.path + notation)}"
             val configOptions: (Configuration) -> Unit = { it.isTransitive = false }
             val config = project.configurations.create(configName, configOptions)
 
@@ -227,14 +237,22 @@ open class FileResolver(val project: Project, val downloadDir: File) {
         resolve(sourceFile.absolutePath, { sourceFile })
     }
 
-    fun group(name: String, configurer: Closure<*>) {
+    fun group(name: String, configurer: FileResolver.() -> Unit) {
         groupCurrent = groups.find { it.name == name } ?: createGroup(name).apply { groups.add(this) }
-        ConfigureUtil.configureSelf(configurer, this)
+        apply(configurer)
         groupCurrent = groupDefault
     }
 
+    fun group(name: String, configurer: Closure<*>) {
+        group(name, { ConfigureUtil.configure(configurer, this) })
+    }
+
+    fun config(configurer: FileGroup.() -> Unit) {
+        groupCurrent.apply(configurer)
+    }
+
     fun config(configurer: Closure<*>) {
-        ConfigureUtil.configureSelf(configurer, groupCurrent)
+        config { ConfigureUtil.configure(configurer, this) }
     }
 
 }