private def executePacker()

in app/packer/PackerRunner.scala [89:157]
63 lines of code
4 McCabe index (conditional complexity)

  private def executePacker(
      bake: Bake,
      playbookFile: Path,
      packerConfigFile: Path,
      eventBus: EventBus,
      debug: Boolean
  ): Future[Int] = {
    val maybeDebug = if (debug) Some("-debug") else None
    val command = Seq(
      packerCmd,
      "build",
      maybeDebug,
      "-machine-readable",
      packerConfigFile.toAbsolutePath.toString
    ) collect {
      case s: String       => s
      case Some(s: String) => s
    }
    val packerCacheDir =
      Files.createTempDirectory(s"amigo-packer-cache-${bake.recipe.id.value}")
    val packerBuilder = new ProcessBuilder()
      .command(command: _*)
      .directory(new File(System.getProperty("java.io.tmpdir")))
    packerBuilder
      .environment()
      .put("PACKER_CACHE_DIR", packerCacheDir.toAbsolutePath.toString)
    val packerProcess = packerBuilder.start()

    val exitValuePromise = Promise[Int]()

    val runnable = new Runnable {
      def run(): Unit = try {
        PackerProcessMonitor.monitorProcess(
          packerProcess,
          exitValuePromise,
          bake.bakeId,
          eventBus
        )
      } finally {
        startNextPacker(_ -= this)
      }
    }
    val listenerThread = new Thread(
      runnable,
      s"Packer process monitor for ${bake.recipe.id.value} #${bake.buildNumber}"
    )
    listenerThread.setDaemon(true)
    startNextPacker(_ += runnable -> listenerThread)

    val exitValueFuture = exitValuePromise.future

    // Make sure to delete the tmp files after Packer completes, regardless of success or failure
    exitValueFuture.onComplete { _ =>
      Try(Files.deleteIfExists(playbookFile))
        .fold(log.error("Failed to delete playbook file", _), _ => ())
      Try(Files.deleteIfExists(packerConfigFile))
        .fold(log.error("Failed to delete config file", _), _ => ())
      Try(
        Files
          .walk(packerCacheDir)
          .map(_.toFile)
          .toScala(List)
          .reverse
          .foreach(_.delete)
      ).fold(log.error("Failed to delete cache directory", _), _ => ())
    }

    exitValueFuture
  }