Merge pull request #1 from pvlugter/sbt-javaagent

Initial version of sbt-javaagent

Author: pvlugter

.gitignore

@@ -0,0 +1,2 @@
+target
+project/project

LICENSE

@@ -0,0 +1,13 @@
+Copyright 2016 Lightbend Inc. [https://www.lightbend.com]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -1,2 +1,63 @@
 # sbt-javaagent
-sbt plugin for adding java agents to projects
+
+This sbt plugin adds Java agents to projects in a general way. It can enable agents in [sbt-native-packager] dists, as compile-time dependencies, in forked run, or in forked tests.
+
+## Plugin dependency
+
+Add the plugin to your `project/plugins.sbt`:
+
+```scala
+addSbtPlugin("com.lightbend.sbt" % "sbt-javaagent" % "0.1.0")
+```
+
+## Java agent
+
+To add a Java agent to an [sbt-native-packager] distribution, enable the `JavaAgent` plugin on a project that also has `JavaAppPackaging` enabled, and then add the agent dependency using the `javaAgents` setting. For example:
+
+```scala
+lazy val distProject = project
+  .in(file("somewhere"))
+  .enablePlugins(JavaAgent, JavaAppPackaging)
+  .settings(
+    javaAgents += "com.example" % "agent" % "1.2.3"
+  )
+```
+
+This will automatically resolve the agent module, bundle the agent artifact in the distribution, and add a `-javaagent` option to the start script.
+
+> **Note**: sbt-javaagent has a dynamic dependency on [sbt-native-packager]. You need to add sbt-native-packager separately.
+
+## Scopes
+
+By default, sbt-javaagent will only add an agent to distributions. Agents can be optionally enabled for compile, run, or test.
+
+The following scopes are supported:
+
+   * **dist** — bundle the agent in production distributions and add a `-javaagent` option to start scripts
+   * **compile** — add the agent as a `provided` dependency so that it's available on the compile classpath
+   * **run** — automatically fork the run and add a `-javaagent` option
+   * **test** — automatically fork tests and add a `-javaagent` option
+
+The plugin can derive these scopes from module configurations.
+
+For example, to add an agent to *compile*, to build against an API provided by an agent, use the `compile` or `provided` configuration:
+
+```scala
+javaAgents += "com.example" % "agent" % "1.2.3" % "compile"
+```
+
+Marking a dependency for *compile* will also automatically enable the agent for *run* as well.
+
+To enable for run or tests, use the `runtime` or `test` configurations.
+
+Multiple configurations can be specified. For example, the following will enable both *compile* and *test* (and implicitly *run*):
+
+```scala
+javaAgents += "com.example" % "agent" % "1.2.3" % "compile;test"
+```
+
+Note that in this case, the agent dependency is actually added under the `provided` configuration, so that a project can compile against the agent and then have the agent provided at runtime using a `-javaagent` option. 
+
+If the *compile* scope is not enabled, then the agent dependency is put under a special `javaagent` configuration so that it doesn't appear as a regular library dependency or on build classpaths.
+
+[sbt-native-packager]: https://github.com/sbt/sbt-native-packager

build.sbt

@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2016 Lightbend, Inc. <http://www.lightbend.com>
+ */
+
+lazy val `sbt-javaagent` = project in file(".")
+
+sbtPlugin := true
+
+name := "sbt-javaagent"
+organization := "com.lightbend.sbt"
+
+// dependencies
+val packagerVersion = "1.0.6"
+addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % packagerVersion % "provided")
+
+// compile settings
+scalacOptions ++= Seq("-encoding", "UTF-8", "-target:jvm-1.6", "-unchecked", "-deprecation", "-feature")
+javacOptions ++= Seq("-encoding", "UTF-8", "-source", "1.6", "-target", "1.6")
+
+// test agent
+lazy val maxwell = project
+  .in(file("maxwell"))
+  .settings(
+    name := "maxwell",
+    organization := "sbt.javaagent.test",
+    autoScalaLibrary := false,
+    crossPaths := false,
+    packageOptions += Package.ManifestAttributes("Premain-Class" -> "maxwell.Maxwell"),
+    publish := ()
+  )
+
+// test settings
+scriptedSettings
+scriptedLaunchOpts ++= Seq(
+  "-Dproject.version=" + version.value,
+  "-Dpackager.version=" + packagerVersion
+)
+scriptedDependencies := {
+  (publishLocal in maxwell).value
+  publishLocal.value
+}
+test in Test := {
+  (test in Test).value
+  ScriptedPlugin.scripted.toTask("").value
+}
+
+// publish settings
+publishMavenStyle := false
+bintrayOrganization := Some("lightbend")
+bintrayRepository := "sbt-plugin-releases"
+bintrayPackage := "sbt-javaagent"
+bintrayReleaseOnPublish := false
+licenses += "Apache-2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0.html")

maxwell/src/main/java/maxwell/Maxwell.java

@@ -0,0 +1,9 @@
+package maxwell;
+
+import java.lang.instrument.Instrumentation;
+
+public class Maxwell {
+    public static void premain(String agentArgs, Instrumentation instrumentation) {
+        System.out.println("Agent 86");
+    }
+}

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.11

project/plugins.sbt

@@ -0,0 +1,8 @@
+/*
+ * Copyright © 2016 Lightbend, Inc. <http://www.lightbend.com>
+ */
+
+addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.3")
+addSbtPlugin("me.lessis"         % "bintray-sbt" % "0.3.0")
+
+libraryDependencies += "org.scala-sbt" % "scripted-plugin" % sbtVersion.value

src/main/scala/com/lightbend/sbt/javaagent/JavaAgent.scala

@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2016 Lightbend, Inc. <http://www.lightbend.com>
+ */
+
+package com.lightbend.sbt.javaagent
+
+import sbt._
+import sbt.Keys._
+
+/**
+ * Plugin for adding Java agents to projects in a general way.
+ * Supports agents as compile-time dependencies, in forked tests, in forked run,
+ * and in `sbt-native-packager` dists through the `JavaAgentPackaging` plugin.
+ */
+object JavaAgent extends AutoPlugin {
+
+  object JavaAgentKeys {
+    val javaAgents = settingKey[Seq[AgentModule]]("Java agent modules enabled for this project.")
+    val resolvedJavaAgents = taskKey[Seq[ResolvedAgent]]("Java agent modules with resolved artifacts.")
+  }
+
+  import JavaAgentKeys._
+
+  val autoImport = JavaAgentKeys
+
+  val AgentConfig = config("javaagent").hide
+
+  case class AgentScope(compile: Boolean = false, test: Boolean = false, run: Boolean = false, dist: Boolean = true)
+
+  case class AgentModule(name: String, module: ModuleID, scope: AgentScope)
+
+  case class ResolvedAgent(agent: AgentModule, artifact: File)
+
+  object AgentModule {
+    import scala.language.implicitConversions
+    implicit def moduleToAgentModule(module: ModuleID): AgentModule = JavaAgent(module)
+  }
+
+  /**
+   * Create an agent module from a module dependency.
+   * Scope is also derived from the given module configuration.
+   */
+  def apply(module: ModuleID, name: String = null, scope: AgentScope = AgentScope()): AgentModule = {
+    val agentName = Option(name).getOrElse(module.name)
+    val confs = module.configurations.toSeq.flatMap(_.split(";"))
+    val inCompile = scope.compile || confs.contains(Compile.name) || confs.contains(Provided.name)
+    val inRun = scope.run || inCompile || confs.contains(Runtime.name)
+    val inTest = scope.test || confs.contains(Test.name)
+    val inDist = scope.dist
+    val configuration = if (inCompile) Provided else AgentConfig
+    val reconfiguredModule = module.copy(configurations = Some(configuration.name))
+    val configuredScope = AgentScope(compile = inCompile, test = inTest, run = inRun, dist = inDist)
+    AgentModule(agentName, reconfiguredModule, configuredScope)
+  }
+
+  override def requires = plugins.JvmPlugin
+
+  override def projectSettings = Seq(
+    javaAgents := Seq.empty,
+    ivyConfigurations += AgentConfig,
+    libraryDependencies ++= javaAgents.value.map(_.module),
+    resolvedJavaAgents := resolveAgents.value,
+    fork in run := enableFork(fork in run, _.scope.run).value,
+    fork in Test := enableFork(fork in Test, _.scope.test).value,
+    javaOptions in run ++= agentOptions(_.agent.scope.run).value,
+    javaOptions in Test ++= agentOptions(_.agent.scope.test).value
+  )
+
+  private def resolveAgents = Def.task[Seq[ResolvedAgent]] {
+    javaAgents.value flatMap { agent =>
+      update.value.matching(exactModuleFilter(agent.module)).headOption map {
+        jar => ResolvedAgent(agent, jar)
+      }
+    }
+  }
+
+  private def exactModuleFilter(module: ModuleID) = new ModuleFilter {
+    def apply(m: ModuleID) = {
+      m.organization == module.organization &&
+      m.name         == module.name &&
+      m.revision     == module.revision
+    }
+  }
+
+  private def enableFork(forkKey: SettingKey[Boolean], enabled: AgentModule => Boolean) = Def.setting[Boolean] {
+    forkKey.value || javaAgents.value.exists(enabled)
+  }
+
+  private def agentOptions(enabled: ResolvedAgent => Boolean) = Def.task[Seq[String]] {
+    resolvedJavaAgents.value filter enabled map { agent =>
+      "-javaagent:" + agent.artifact.absolutePath
+    }
+  }
+
+}

src/main/scala/com/lightbend/sbt/javaagent/JavaAgentPackaging.scala

@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2016 Lightbend, Inc. <http://www.lightbend.com>
+ */
+
+package com.lightbend.sbt.javaagent
+
+import sbt._
+import sbt.Keys._
+import com.typesafe.sbt.packager.archetypes.JavaAppPackaging.autoImport.bashScriptExtraDefines
+import com.typesafe.sbt.packager.universal.UniversalPlugin.autoImport.Universal
+import java.io.File
+
+/**
+ * Plugin for adding Java agents to `sbt-native-packager` distributions.
+ */
+object JavaAgentPackaging extends AutoPlugin {
+  import JavaAgent.JavaAgentKeys._
+
+  override def trigger = allRequirements
+
+  override def requires = JavaAgent && PluginRef("com.typesafe.sbt.packager.archetypes.JavaAppPackaging")
+
+  override def projectSettings = Seq(
+    mappings in Universal ++= agentMappings.value,
+    bashScriptExtraDefines ++= agentScriptOptions.value
+  )
+
+  private def agentMappings = Def.task[Seq[(File, String)]] {
+    resolvedJavaAgents.value filter (_.agent.scope.dist) map { resolved =>
+      resolved.artifact -> (Project.normalizeModuleID(resolved.agent.name) + File.separator + resolved.artifact.name)
+    }
+  }
+
+  private def agentScriptOptions = Def.task[Seq[String]] {
+    agentMappings.value map {
+      case (_, path) => s"""addJava "-javaagent:$${app_home}/../${normalizePath(path)}" """
+    }
+  }
+
+  private def normalizePath(path: String, separator: Char = File.separatorChar): String = {
+    if (separator == '/') path else path.replace(separator, '/')
+  }
+
+  /**
+   * Reflectively load an auto plugin if it's on the classpath, otherwise
+   * return an empty plugin that won't trigger all-requirements loading.
+   * See also: https://github.com/sbt/sbt/issues/2538
+   */
+  private def PluginRef(className: String): AutoPlugin = {
+    try {
+      val name = if (className.endsWith("$")) className else (className + "$")
+      Class.forName(name).asInstanceOf[Class[AutoPlugin]]
+        .getDeclaredField("MODULE$").get(null) match {
+          case plugin: AutoPlugin => plugin
+          case _ => throw new RuntimeException(s"[$name] is not an AutoPlugin object")
+        }
+    } catch {
+      case _: Throwable => NoPlugin
+    }
+  }
+
+  object NoPlugin extends AutoPlugin
+
+}

src/sbt-test/agent/compile/build.sbt

@@ -0,0 +1,3 @@
+lazy val agentCompile = project in file(".") enablePlugins (JavaAgent, JavaAppPackaging)
+
+javaAgents += "sbt.javaagent.test" % "maxwell" % sys.props("project.version") % "compile"