chore: bump version of gatling-enterprise-commons

Modifications:
* Handle new enterprise plugin instanciation
* Rework command arguments parsers

build.sbt

@@ -9,7 +9,7 @@ githubPath := "gatling/gatling-sbt-plugin"
 
 libraryDependencies ++= Seq(
   "org.scalatest" %% "scalatest"                         % "3.2.18" % Test,
-  "io.gatling"     % "gatling-enterprise-plugin-commons" % "1.9.0-M14"
+  "io.gatling"     % "gatling-enterprise-plugin-commons" % "1.9.0-M17"
 )
 
 scriptedLaunchOpts := {

src/main/scala/io/gatling/sbt/settings/gatling/EnterprisePluginTask.scala

@@ -16,23 +16,43 @@
 
 package io.gatling.sbt.settings.gatling
 
-import io.gatling.plugin.{ BatchEnterprisePlugin, BatchEnterprisePluginClient, InteractiveEnterprisePlugin, InteractiveEnterprisePluginClient }
-import io.gatling.sbt.settings.gatling.EnterpriseClient.enterpriseClientTask
-import io.gatling.sbt.settings.gatling.EnterprisePluginIO.{ enterprisePluginIOTask, enterprisePluginLoggerTask }
+import io.gatling.plugin.{ BatchEnterprisePlugin, EnterprisePlugin, EnterprisePluginProvider, PluginConfiguration }
+import io.gatling.plugin.model.BuildTool
+import io.gatling.sbt.BuildInfo
+import io.gatling.sbt.GatlingKeys._
+import io.gatling.sbt.settings.gatling.EnterprisePluginIO._
 import io.gatling.sbt.settings.gatling.EnterpriseUtils.InitializeTask
 
-import sbt.{ Configuration, Def }
+import sbt._
 
 object EnterprisePluginTask {
-  def batchEnterprisePluginTask[E >: BatchEnterprisePlugin](config: Configuration): InitializeTask[E] = Def.task {
-    val enterpriseClient = enterpriseClientTask(config).value
-    val logger = enterprisePluginLoggerTask.value
-    new BatchEnterprisePluginClient(enterpriseClient, logger)
+  def batchEnterprisePluginTask(config: Configuration): InitializeTask[BatchEnterprisePlugin] = Def.task {
+    val configuration = pluginConfiguration(config, requireBatchMode = true).value
+    EnterprisePluginProvider.getBatchInstance(configuration)
   }
 
-  def interactiveEnterprisePluginTask[E >: InteractiveEnterprisePlugin](config: Configuration): InitializeTask[E] = Def.task {
-    val enterpriseClient = enterpriseClientTask(config).value
-    val pluginIO = enterprisePluginIOTask.value
-    new InteractiveEnterprisePluginClient(enterpriseClient, pluginIO)
+  def enterprisePluginTask(config: Configuration, requireBatchMode: Boolean): InitializeTask[EnterprisePlugin] = Def.task {
+    val configuration = pluginConfiguration(config, requireBatchMode).value
+    EnterprisePluginProvider.getInstance(configuration)
   }
+
+  private def pluginConfiguration(config: Configuration, requireBatchMode: Boolean): InitializeTask[PluginConfiguration] =
+    Def.task {
+      val url = (config / enterpriseUrl).value
+      val apiToken = (config / enterpriseApiToken).value
+      val privateControlPlaneUrl = (config / enterpriseControlPlaneUrl).value
+      val pluginIO = enterprisePluginIOTask.value
+      val logger = enterprisePluginLoggerTask.value
+
+      if (apiToken.isEmpty) {
+        logger.error(
+          s"""An API token is required to call the Gatling Enterprise server; see https://gatling.io/docs/enterprise/cloud/reference/admin/api_tokens/ and create a token with the role 'Configurer'.
+             |You can then set your API token's value in the environment variable GATLING_ENTERPRISE_API_TOKEN, pass it with -Dgatling.enterprise.apiToken=<apiToken>, or add the configuration to your SBT settings, e.g.:
+             |${config.id} / enterpriseApiToken := MY_API_TOKEN_VALUE""".stripMargin
+        )
+        throw ErrorAlreadyLoggedException
+      }
+
+      new PluginConfiguration(url, apiToken, privateControlPlaneUrl.orNull, BuildTool.SBT, BuildInfo.version, requireBatchMode, pluginIO)
+    }
 }

src/main/scala/io/gatling/sbt/settings/gatling/TaskEnterpriseDeploy.scala

@@ -20,7 +20,6 @@ import scala.util.Try
 
 import io.gatling.plugin.deployment.DeploymentConfiguration
 import io.gatling.plugin.model._
-import io.gatling.sbt.BuildInfo
 import io.gatling.sbt.GatlingKeys._
 import io.gatling.sbt.settings.gatling.EnterpriseUtils._
 
@@ -41,9 +40,7 @@ class TaskEnterpriseDeploy(config: Configuration, enterprisePackage: TaskEnterpr
         descriptorFile,
         packageFile,
         artifactId,
-        controlPlaneUrl.isDefined,
-        BuildTool.SBT,
-        BuildInfo.version
+        controlPlaneUrl.isDefined
       )
     }.recoverWith(recoverEnterprisePluginException(logger)).get
   }

src/main/scala/io/gatling/sbt/settings/gatling/TaskEnterpriseStart.scala

@@ -16,40 +16,61 @@
 
 package io.gatling.sbt.settings.gatling
 
-import scala.util.{ Failure, Success, Try }
+import scala.util._
 
 import io.gatling.plugin.EnterprisePlugin
 import io.gatling.plugin.model.RunSummary
 import io.gatling.sbt.GatlingKeys._
-import io.gatling.sbt.settings.gatling.EnterprisePluginTask._
-import io.gatling.sbt.settings.gatling.EnterpriseUtils._
+import io.gatling.sbt.settings.gatling.EnterpriseUtils.InitializeInputTask
+import io.gatling.sbt.settings.gatling.TaskEnterpriseStart.CommandArgs.CommandArgsParser
 
 import sbt.{ Configuration, Def }
 import sbt.Keys._
 import sbt.complete.DefaultParsers._
 import sbt.internal.util.ManagedLogger
+import sbt.internal.util.complete.Parser
 
-class TaskEnterpriseStart(config: Configuration, taskEnterpriseDeploy: TaskEnterpriseDeploy) extends RecoverEnterprisePluginException(config) {
+object TaskEnterpriseStart {
+  object CommandArgs {
+    private val Default = CommandArgs(simulationName = None, requireBatchMode = false)
+
+    private val SimulationNameParser: Parser[String] = StringBasic.examples("<simulation name>")
+
+    private val RequireBatchModeParser: Parser[CommandArgs => CommandArgs] =
+      token("--batch-mode" ^^^ (_.copy(requireBatchMode = true)))
 
-  private val enterprisePluginTask = Def.inputTaskDyn[EnterprisePlugin] {
-    val enterpriseStartCommand = EnterpriseStartCommand.parser.parsed
-    val batchMode = enterpriseStartCommand.batchMode || System.console() == null
-    if (batchMode) batchEnterprisePluginTask(config)
-    else interactiveEnterprisePluginTask(config)
+    private val NoBatchModeParser: Parser[CommandArgs => CommandArgs] =
+      token("--no-batch-mode" ^^^ (_.copy(requireBatchMode = System.console() == null)))
+
+    val CommandArgsParser: Parser[CommandArgs] =
+      ((Space ~> (NoBatchModeParser | RequireBatchModeParser)).* ~ (Space ~> SimulationNameParser).?)
+        .map { case (results, simulationName) =>
+          results
+            .foldLeft(Default) { (current, op) =>
+              op.apply(current)
+            }
+            .copy(simulationName = simulationName)
+        }
   }
+  final case class CommandArgs(simulationName: Option[String], requireBatchMode: Boolean)
+}
+
+class TaskEnterpriseStart(config: Configuration, taskEnterpriseDeploy: TaskEnterpriseDeploy) extends RecoverEnterprisePluginException(config) {
+  val enterpriseSimulationStart: InitializeInputTask[Unit] = Def.inputTaskDyn {
+    val commandArgs = CommandArgsParser.parsed
 
-  val enterpriseSimulationStart: InitializeInputTask[Unit] = Def.inputTask {
-    val logger = streams.value.log
-    val enterprisePlugin = enterprisePluginTask.evaluated
-    val deploymentInfo = taskEnterpriseDeploy.enterpriseDeploy.value
-    val waitForRunEndSetting = waitForRunEnd.value
-    val simulationName = spaceDelimited("<arg>").parsed.headOption
+    Def.task {
+      val logger = streams.value.log
+      val enterprisePlugin = EnterprisePluginTask.enterprisePluginTask(config, commandArgs.requireBatchMode).value
+      val deploymentInfo = taskEnterpriseDeploy.enterpriseDeploy.value
+      val waitForRunEndSetting = waitForRunEnd.value
 
-    val runSummary = enterprisePlugin.startSimulation(simulationName.orNull, deploymentInfo)
+      val runSummary = enterprisePlugin.startSimulation(commandArgs.simulationName.orNull, deploymentInfo)
 
-    logStartResult(logger, runSummary, waitForRunEndSetting, baseUrl = (config / enterpriseUrl).value)
+      logStartResult(logger, runSummary, waitForRunEndSetting, baseUrl = (config / enterpriseUrl).value)
 
-    maybeWaitForRunEnd(logger, enterprisePlugin, waitForRunEndSetting, runSummary)
+      maybeWaitForRunEnd(logger, enterprisePlugin, waitForRunEndSetting, runSummary)
+    }
   }
 
   private def logStartResult(logger: ManagedLogger, runSummary: RunSummary, waitForRunEndSetting: Boolean, baseUrl: sbt.URL): Unit = {