s3_website_revived 4.0.0

data/src/main/scala/s3/website/model/Site.scala

@@ -0,0 +1,159 @@
+package s3.website.model
+
+import java.io.File
+import s3.website.Push.CliArgs
+import s3.website.model.Ssg.autodetectSiteDir
+
+import scala.util.Try
+import org.yaml.snakeyaml.Yaml
+import s3.website.model.Config._
+import scala.io.Source.fromFile
+import scala.language.postfixOps
+import s3.website.{S3Key, Logger, ErrorReport}
+import scala.util.Failure
+import s3.website.model.Config.UnsafeYaml
+import scala.util.Success
+
+case class Site(rootDirectory: File, config: Config) {
+  def resolveS3Key(file: File) = S3Key.build(
+    file.getAbsolutePath.replace(rootDirectory.getAbsolutePath, "").replace(File.separator,"/").replaceFirst("^/", ""),
+    config.s3_key_prefix
+  )
+}
+
+object Site {
+  def parseConfig(implicit logger: Logger, yamlConfig: S3_website_yml): Either[ErrorReport, Config] = {
+    val yamlObjectTry = for {
+      yamlString <- Try(fromFile(yamlConfig.file).mkString)
+      yamlWithErbEvaluated <- erbEval(yamlString, yamlConfig)
+      yamlObject <- Try(new Yaml() load yamlWithErbEvaluated)
+    } yield yamlObject
+
+    yamlObjectTry match {
+      case Success(yamlObject) =>
+        implicit val unsafeYaml = UnsafeYaml(yamlObject)
+        for {
+          s3_id <- loadOptionalString("s3_id").right
+          s3_secret <- loadOptionalString("s3_secret").right
+          session_token <- loadOptionalString("session_token").right
+          profile <- loadOptionalString("profile").right
+          profile_assume_role_arn <- loadOptionalString("profile_assume_role_arn").right
+          s3_bucket <- loadRequiredString("s3_bucket").right
+          s3_endpoint <- loadEndpoint.right
+          site <- loadOptionalString("site").right
+          max_age <- loadMaxAge.right
+          cache_control <- loadCacheControl.right
+          gzip <- loadOptionalBooleanOrStringSeq("gzip").right
+          gzip_zopfli <- loadOptionalBoolean("gzip_zopfli").right
+          extensionless_mime_type <- loadOptionalString("extensionless_mime_type").right
+          s3_key_prefix <- loadOptionalString("s3_key_prefix").right
+          ignore_on_server <- loadOptionalS3KeyRegexes("ignore_on_server").right
+          exclude_from_upload <- loadOptionalS3KeyRegexes("exclude_from_upload").right
+          s3_reduced_redundancy <- loadOptionalBoolean("s3_reduced_redundancy").right
+          cloudfront_distribution_id <- loadOptionalString("cloudfront_distribution_id").right
+          cloudfront_invalidate_root <- loadOptionalBoolean("cloudfront_invalidate_root").right
+          content_type <- loadContentType.right
+          concurrency_level <- loadOptionalInt("concurrency_level").right
+          cloudfront_wildcard_invalidation <- loadOptionalBoolean("cloudfront_wildcard_invalidation").right
+          redirects <- loadRedirects(s3_key_prefix).right
+          treat_zero_length_objects_as_redirects <- loadOptionalBoolean("treat_zero_length_objects_as_redirects").right
+        } yield {
+          gzip_zopfli.foreach(_ => logger.info(
+            """|Zopfli is not currently supported. Falling back to regular gzip.
+              |If you find a stable Java implementation for zopfli, please send an email to lauri.lehmijoki@iki.fi about it."""
+              .stripMargin))
+          extensionless_mime_type.foreach(_ => logger.info(
+            s"Ignoring the extensionless_mime_type setting in $yamlConfig. Counting on Apache Tika to infer correct mime types.")
+          )
+          Config(
+            s3_id,
+            s3_secret,
+            session_token,
+            profile,
+            profile_assume_role_arn,
+            s3_bucket,
+            s3_endpoint getOrElse S3Endpoint.defaultEndpoint,
+            site,
+            max_age,
+            cache_control,
+            gzip,
+            gzip_zopfli,
+            s3_key_prefix,
+            ignore_on_server = ignore_on_server,
+            exclude_from_upload = exclude_from_upload,
+            s3_reduced_redundancy,
+            cloudfront_distribution_id,
+            cloudfront_invalidate_root,
+            content_type,
+            redirects,
+            concurrency_level.fold(20)(_ max 20),
+            cloudfront_wildcard_invalidation,
+            treat_zero_length_objects_as_redirects
+          )
+        }
+      case Failure(error) =>
+        Left(ErrorReport(error))
+    }
+  }
+
+  def loadSite(implicit yamlConfig: S3_website_yml, cliArgs: CliArgs, workingDirectory: File, logger: Logger): Either[ErrorReport, Site] =
+    parseConfig.right.flatMap { cfg =>
+      implicit val config: Config = cfg
+      resolveSiteDir.right.map(Site(_, config))
+    }
+
+  def noSiteFound(explanation: String) =
+    s"""|
+        |$explanation
+        |Either use the --site=DIR command-line argument or define the location of the site in s3_website.yml.
+        |
+        |Here's an example of how you can define the site directory in s3_website.yml:
+        |   site: dist/website""".stripMargin
+
+  def resolveSiteDir(implicit yamlConfig: S3_website_yml, config: Config, cliArgs: CliArgs, workingDirectory: File): Either[ErrorReport, File] = {
+    val siteFromAutoDetect = if (config.site.isEmpty) { autodetectSiteDir(workingDirectory) } else { None }
+    val errOrSiteFromCliArgs: Either[ErrorReport, Option[File]] = Option(cliArgs.site) match {
+      case Some(siteDirFromCliArgs) =>
+        val f = new File(siteDirFromCliArgs)
+        if (f.exists())
+          Right(Some(f))
+        else
+          Left(ErrorReport(noSiteFound(s"Could not find a site at $siteDirFromCliArgs. Check the --site argument.")))
+      case None => Right(None)
+    }
+
+    val errOrAvailableSiteDirs: Either[ErrorReport, List[File]] = for {
+      s1 <- errOrSiteFromCliArgs.right
+      s2 <- siteFromConfig.right
+      s3 <- Right(siteFromAutoDetect).right
+    } yield {
+      (s1 :: s2 :: s3 :: Nil) collect {
+        case Some(file) => file
+      }
+    }
+    errOrAvailableSiteDirs.right.flatMap {
+      case mostPreferredSiteDir :: xs => Right(mostPreferredSiteDir)
+      case Nil => Left(ErrorReport(noSiteFound("Could not find a website.")))
+    }
+  }
+
+  def siteFromConfig(implicit yamlConfig: S3_website_yml, config: Config, workingDirectory: File): Either[ErrorReport, Option[File]] = {
+    val siteConfig = config
+      .site
+      .map(new File(_))
+      .map { siteDir =>
+        if (siteDir.isAbsolute) siteDir
+        else new File(yamlConfig.file.getParentFile, siteDir.getPath)
+      }
+
+    siteConfig match {
+      case s @ Some(siteDir) =>
+        if (siteDir.exists())
+          Right(s)
+        else
+          Left(ErrorReport(noSiteFound(s"Could not find a website. (The site setting in s3_website.yml points to a non-existing file $siteDir)")))
+      case None =>
+        Right(None)
+    }
+  }
+}

data/src/main/scala/s3/website/model/push.scala

@@ -0,0 +1,225 @@
+package s3.website.model
+
+import java.io.File.createTempFile
+import java.io._
+import java.util.zip.{GZIPInputStream, GZIPOutputStream}
+
+import com.amazonaws.services.s3.model.S3ObjectSummary
+import org.apache.commons.codec.digest.DigestUtils
+import org.apache.commons.io.IOUtils
+import org.apache.tika.Tika
+import s3.website._
+import s3.website.model.Encoding.{Gzip, Zopfli}
+import s3.website.model.Upload.{amountOfMagicGzipBytes, tika}
+
+import scala.concurrent.{ExecutionContextExecutor, Future}
+import scala.util.Try
+
+object Encoding {
+
+  val defaultGzipExtensions = ".html" :: ".css" :: ".js" :: ".txt" :: ".ico" :: Nil
+
+  case class Gzip()
+  case class Zopfli()
+}
+
+sealed trait UploadType {
+  val pushAction: PushAction
+}
+
+case object NewFile extends UploadType {
+  val pushAction = Created
+}
+case object FileUpdate extends UploadType {
+  val pushAction = Updated
+}
+
+case object RedirectFile extends UploadType {
+  val pushAction = Redirected
+}
+
+case class Upload(originalFile: File, uploadType: UploadType)(implicit site: Site, logger: Logger) {
+  lazy val s3Key = site.resolveS3Key(originalFile)
+
+  lazy val encodingOnS3: Option[Either[Gzip, Zopfli]] =
+    site.config.gzip.flatMap { (gzipSetting: Either[Boolean, Seq[String]]) =>
+      val shouldZipThisFile = gzipSetting.fold(
+        shouldGzip => Encoding.defaultGzipExtensions exists s3Key.key.endsWith,
+        fileExtensions => fileExtensions exists s3Key.key.endsWith
+      )
+      if (shouldZipThisFile && site.config.gzip_zopfli.isDefined)
+        Some(Right(Zopfli()))
+      else if (shouldZipThisFile)
+        Some(Left(Gzip()))
+      else
+        None
+    }
+
+  lazy val gzipEnabledByConfig: Boolean = encodingOnS3.fold(false)((algorithm: Either[Gzip, Zopfli]) => true)
+
+  lazy val contentType: Try[String] = tika map { tika =>
+    val file = // This file contains the data that the user should see after decoding the the transport protocol (HTTP) encoding (practically: after ungzipping)
+      if (fileIsGzippedByExternalBuildTool) {
+        val unzippedFile = createTempFile("unzipped", originalFile.getName)
+        unzippedFile.deleteOnExit()
+        using(new GZIPInputStream(fis(originalFile))) { stream =>
+          IOUtils.copy(stream, new FileOutputStream(unzippedFile))
+        }
+        unzippedFile
+      } else {
+        originalFile
+      }
+    val mimeType =
+      site.config.content_type
+        .flatMap { _.globMatch(s3Key) }
+        .getOrElse { tika.detect(file) }
+    if (mimeType.startsWith("text/") || mimeType == "application/json")
+      mimeType + "; charset=utf-8"
+    else
+      mimeType
+  }
+
+  lazy val maxAge: Option[Int] =
+    site.config.max_age.flatMap(
+      _ fold(
+        (maxAge: Int) => Some(maxAge),
+        (globs: S3KeyGlob[Int]) => globs.globMatch(s3Key)
+      )
+    )
+
+  lazy val cacheControl: Option[String] =
+    site.config.cache_control.flatMap(
+      _ fold(
+        (cacheCtrl: String) => Some(cacheCtrl),
+        (globs: S3KeyGlob[String]) => globs.globMatch(s3Key)
+      )
+    )
+
+  /**
+   * May throw an exception, so remember to call this in a Try or Future monad
+   */
+  lazy val md5 = uploadFile map { file =>
+    using(fis { file }) { DigestUtils.md5Hex }
+  }
+
+  // This is the file we should try to upload
+  lazy val uploadFile: Try[File] =
+    if (gzipEnabledByConfig)
+      Try {
+        if (fileIsGzippedByExternalBuildTool) {
+          logger.debug(s"File ${originalFile.getAbsolutePath} is already gzipped. Skipping gzip.")
+          originalFile
+        } else {
+          logger.debug(s"Gzipping file ${originalFile.getName}")
+          val tempFile = createTempFile(originalFile.getName, "gzip")
+          tempFile.deleteOnExit()
+          using(new GZIPOutputStream(new FileOutputStream(tempFile))) { stream =>
+            IOUtils.copy(fis(originalFile), stream)
+          }
+          tempFile
+        }
+      }
+    else
+      Try(originalFile)
+
+  private lazy val fileIsGzippedByExternalBuildTool = gzipEnabledByConfig && originalFileIsGzipped
+
+  private lazy val originalFileIsGzipped =
+    if (originalFile.length() < amountOfMagicGzipBytes) {
+      false
+    } else {
+      val fis = new FileInputStream(originalFile)
+      val firstTwoBytes = Array.fill[Byte](amountOfMagicGzipBytes)(0)
+      fis.read(firstTwoBytes, 0, amountOfMagicGzipBytes)
+      val head = firstTwoBytes(0) & 0xff | (firstTwoBytes(1) << 8) & 0xff00
+      head == GZIPInputStream.GZIP_MAGIC
+    }
+
+  private[this] def fis(file: File): InputStream = new FileInputStream(file)
+  private[this] def using[T <: Closeable, R](cl: T)(f: (T) => R): R = try f(cl) finally cl.close()
+}
+
+object Upload {
+  lazy val tika = Try(new Tika())
+  private val amountOfMagicGzipBytes = 2
+}
+
+object Files {
+  def recursiveListFiles(f: File): Seq[File] = {
+    val these = f.listFiles
+    if (these != null)
+      these ++ these.filter(_.isDirectory).flatMap(recursiveListFiles)
+    else
+      Nil
+  }
+
+  def listSiteFiles(implicit site: Site, logger: Logger) = {
+    def excludeFromUpload(s3Key: S3Key) = {
+      val excludeByConfig = site.config.exclude_from_upload exists {
+        _.s3KeyRegexes.exists(_ matches s3Key)
+      }
+      val neverUpload = "s3_website.yml" :: ".env" :: Nil map (k => S3Key.build(k, site.config.s3_key_prefix))
+      val doNotUpload = excludeByConfig || (neverUpload contains s3Key)
+      if (doNotUpload) logger.debug(s"Excluded $s3Key from upload")
+      doNotUpload
+    }
+    recursiveListFiles(site.rootDirectory)
+      .filterNot(_.isDirectory)
+      .filterNot(f => excludeFromUpload(site.resolveS3Key(f)))
+  }
+}
+
+case class Redirect(s3Key: S3Key, redirectTarget: String, needsUpload: Boolean) {
+  def uploadType = RedirectFile
+}
+
+private case class RedirectSetting(source: S3Key, target: String)
+
+object Redirect {
+  type Redirects = Future[Either[ErrorReport, Seq[Redirect]]]
+
+  def resolveRedirects(s3FileFutures: Future[Either[ErrorReport, Seq[S3File]]])
+                      (implicit config: Config, executor: ExecutionContextExecutor, pushOptions: PushOptions): Redirects = {
+    val redirectSettings = config.redirects.fold(Nil: Seq[RedirectSetting]) { sourcesToTargets =>
+      sourcesToTargets.foldLeft(Seq(): Seq[RedirectSetting]) {
+        (redirects, sourceToTarget) =>
+          redirects :+ RedirectSetting(sourceToTarget._1, applyRedirectRules(sourceToTarget._2))
+      }
+    }
+    def redirectsWithExistsOnS3Info =
+      s3FileFutures.map(_.right.map { s3Files =>
+        val existingRedirectKeys = s3Files.filter(_.size == 0).map(_.s3Key).toSet
+        redirectSettings.map(redirectSetting => 
+          Redirect(redirectSetting, needsUpload = !existingRedirectKeys.contains(redirectSetting.source))
+        )
+      })
+    val uploadOnlyMissingRedirects =
+      config.treat_zero_length_objects_as_redirects.contains(true) && !pushOptions.force
+    val allConfiguredRedirects = Future(Right(redirectSettings.map(redirectSetting =>
+      Redirect(redirectSetting, needsUpload = true)
+    )))
+    if (uploadOnlyMissingRedirects) 
+      redirectsWithExistsOnS3Info 
+    else 
+      allConfiguredRedirects
+  }
+
+  private def applyRedirectRules(redirectTarget: String)(implicit config: Config) = {
+    val isExternalRedirect = redirectTarget.matches("https?:\\/\\/.*")
+    val isInSiteRedirect = redirectTarget.startsWith("/")
+    if (isInSiteRedirect || isExternalRedirect)
+      redirectTarget
+    else
+      s"${config.s3_key_prefix.map(prefix => s"/$prefix").getOrElse("")}/$redirectTarget"
+  }
+
+  def apply(redirectSetting: RedirectSetting, needsUpload: Boolean): Redirect =
+      Redirect(redirectSetting.source, redirectSetting.target, needsUpload)
+}
+
+case class S3File(s3Key: S3Key, md5: MD5, size: Long)
+
+object S3File {
+  def apply(summary: S3ObjectSummary)(implicit site: Site): S3File =
+    S3File(S3Key.build(summary.getKey, None), summary.getETag, summary.getSize)
+}

data/src/main/scala/s3/website/model/ssg.scala

@@ -0,0 +1,30 @@
+package s3.website.model
+
+import java.io.File
+import s3.website.model.Files.recursiveListFiles
+
+// ssg = static site generator
+trait Ssg {
+  def outputDirectory: String
+}
+
+object Ssg {
+  val automaticallySupportedSiteGenerators = Jekyll :: Nanoc :: Middleman :: Nil
+
+  def autodetectSiteDir(workingDirectory: File): Option[File] =
+    recursiveListFiles(workingDirectory).find { file =>
+      file.isDirectory && automaticallySupportedSiteGenerators.exists(ssg => file.getAbsolutePath.endsWith(ssg.outputDirectory))
+    }
+}
+
+case object Jekyll extends Ssg {
+  def outputDirectory = "_site"
+}
+
+case object Nanoc extends Ssg {
+  def outputDirectory = s"public${File.separatorChar}output"
+}
+
+case object Middleman extends Ssg {
+  def outputDirectory = "build"
+}

data/src/main/scala/s3/website/package.scala

@@ -0,0 +1,182 @@
+package s3
+
+import s3.website.Ruby._
+
+import scala.concurrent.{ExecutionContextExecutor, Future}
+import scala.concurrent.duration.{TimeUnit, Duration}
+import s3.website.S3.{PushSuccessReport, PushFailureReport}
+import com.amazonaws.AmazonServiceException
+import s3.website.model.{Config, Site}
+import java.io.File
+
+import scala.util.matching.Regex
+
+package object website {
+  trait Report {
+    def reportMessage: String
+  }
+  trait SuccessReport extends Report
+
+  trait ErrorReport extends Report
+
+  object ErrorReport {
+    def apply(t: Throwable)(implicit logger: Logger) = new ErrorReport {
+      override def reportMessage = errorMessage(t)
+    }
+
+    def apply(msg: String) = new ErrorReport {
+      override def reportMessage = msg
+    }
+
+    def errorMessage(msg: String, t: Throwable)(implicit logger: Logger): String = s"$msg (${errorMessage(t)})"
+
+    def errorMessage(t: Throwable)(implicit logger: Logger): String =  {
+      val extendedReport =
+        if (logger.verboseOutput)
+          Some(t.getStackTrace)
+        else
+          None
+      s"${t.getMessage}${extendedReport.fold("")(stackTraceElems => "\n" + stackTraceElems.mkString("\n"))}"
+    }
+  }
+
+  trait RetrySetting {
+    def retryTimeUnit: TimeUnit
+  }
+  
+  trait PushOptions {
+    /**
+     * @return true if the CLI option --dry-run is on
+     */
+    def dryRun: Boolean
+
+    /**
+     * @return true if the CLI option --force is on
+     */
+    def force: Boolean
+  }
+
+  case class S3KeyRegex(keyRegex: Regex) {
+    def matches(s3Key: S3Key) = rubyRegexMatches(s3Key.key, keyRegex.pattern.pattern())
+  }
+
+  trait S3Key {
+    val key: String
+    override def toString = key
+  }
+
+  object S3Key {
+    def prefix(s3_key_prefix: Option[String]) = s3_key_prefix.map(prefix => if (prefix.endsWith("/")) prefix else prefix + "/").getOrElse("")
+
+    def isIgnoredBecauseOfPrefix(s3Key: S3Key)(implicit site: Site) = s3Key.key.startsWith(prefix(site.config.s3_key_prefix))
+
+    case class S3KeyClass(key: String) extends S3Key
+    def build(key: String, s3_key_prefix: Option[String]): S3Key = S3KeyClass(prefix(s3_key_prefix) + key)
+  }
+  
+  case class S3KeyGlob[T](globs: Map[String, T]) {
+    def globMatch(s3Key: S3Key): Option[T] = {
+      def respectMostSpecific(globs: Map[String, T]) = globs.toSeq.sortBy(_._1.length).reverse
+      val matcher = (glob: String, value: T) =>
+        rubyRuntime.evalScriptlet(
+          s"""|# encoding: utf-8
+             |File.fnmatch('$glob', "$s3Key")""".stripMargin)
+          .toJava(classOf[Boolean])
+          .asInstanceOf[Boolean]
+      val fileGlobMatch = respectMostSpecific(globs) find Function.tupled(matcher)
+      fileGlobMatch map (_._2)
+    }
+  }
+  
+  case class S3KeyRegexes(s3KeyRegexes: Seq[S3KeyRegex]) {
+    def matches(s3Key: S3Key) = s3KeyRegexes exists (
+      (keyRegex: S3KeyRegex) => keyRegex matches s3Key
+    )
+  }
+
+  type UploadDuration = Long
+
+  trait PushAction {
+    def actionName = getClass.getSimpleName.replace("$", "") // case object class names contain the '$' char
+
+    def renderVerb(implicit pushOptions: PushOptions): String =
+      if (pushOptions.dryRun)
+        s"Would have ${actionName.toLowerCase}"
+      else
+        s"$actionName"
+  }
+  case object Created     extends PushAction
+  case object Updated     extends PushAction
+  case object Redirected  extends PushAction
+  case object Deleted     extends PushAction
+  case object Transferred extends PushAction
+  case object Invalidated extends PushAction
+  case object Applied     extends PushAction
+  case object PushNothing extends PushAction {
+    override def renderVerb(implicit pushOptions: PushOptions) =
+      if (pushOptions.dryRun)
+        s"Would have pushed nothing"
+      else
+        s"There was nothing to push"
+  }
+  case object Deploy      extends PushAction {
+    override def renderVerb(implicit pushOptions: PushOptions) =
+      if (pushOptions.dryRun)
+        s"Simulating the deployment of"
+      else
+        s"Deploying"
+  }
+
+  type PushErrorOrSuccess = Either[PushFailureReport, PushSuccessReport]
+
+  type Attempt = Int
+
+  type MD5 = String
+
+  def retry[L <: Report, R](attempt: Attempt)
+                           (createFailureReport: (Throwable) => L, retryAction: (Attempt) => Future[Either[L, R]])
+                           (implicit retrySetting: RetrySetting, ec: ExecutionContextExecutor, logger: Logger):
+  PartialFunction[Throwable, Future[Either[L, R]]] = {
+    case error: Throwable if attempt == 6 || isIrrecoverable(error) =>
+      val failureReport = createFailureReport(error)
+      logger.fail(failureReport.reportMessage)
+      Future(Left(failureReport))
+    case error: Throwable =>
+      val failureReport = createFailureReport(error)
+      val sleepDuration = Duration(fibs.drop(attempt + 1).head, retrySetting.retryTimeUnit)
+      logger.pending(s"${failureReport.reportMessage}. Trying again in $sleepDuration.")
+      Thread.sleep(sleepDuration.toMillis)
+      retryAction(attempt + 1)
+  }
+
+  def isIrrecoverable(error: Throwable) = {
+    val httpStatusCode =
+      error match {
+        case exception: AmazonServiceException => Some(exception.getStatusCode)
+        case _ => None
+      }
+    val isAwsTimeoutException =
+      error match {
+        case exception: AmazonServiceException =>
+          // See http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList
+          exception.getErrorCode == "RequestTimeout"
+        case _ => false
+      }
+    httpStatusCode.exists(c => c >= 400 && c < 500) && !isAwsTimeoutException
+  }
+  
+  implicit class NumReport(val num: Int) extends AnyVal {
+    def ofType(itemType: String) = countToString(num, itemType)
+
+    private def countToString(count: Int, singular: String) = {
+      def plural = s"${singular}s"
+      s"$count ${if (count > 1) plural else singular}"
+    }
+  }
+
+  implicit def site2Config(implicit site: Site): Config = site.config
+
+  type ErrorOrFile = Either[ErrorReport, File]
+
+  lazy val fibs: Stream[Int] = 0 #:: 1 #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }
+}

data/src/test/scala/s3/website/AwsSdkSpec.scala

@@ -0,0 +1,15 @@
+package s3.website
+
+import com.amazonaws.http.AmazonHttpClient
+import org.apache.commons.logging.LogFactory
+import org.specs2.mutable.Specification
+
+class AwsSdkSpec extends Specification {
+
+  "AWS SDK" should {
+    "not log INFO level messages" in {
+      // See https://github.com/laurilehmijoki/s3_website/issues/104 for discussion
+      LogFactory.getLog(classOf[AmazonHttpClient]).isInfoEnabled must beFalse
+    }
+  }
+}