s3_website_monadic 0.0.1

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

@@ -0,0 +1,191 @@
+package s3.website
+
+import s3.website.model.Site._
+import scala.concurrent.{ExecutionContextExecutor, Future, Await}
+import scala.collection.parallel.ForkJoinTaskSupport
+import scala.concurrent.forkjoin.ForkJoinPool
+import scala.concurrent.duration._
+import com.lexicalscope.jewel.cli.CliFactory
+import scala.language.postfixOps
+import s3.website.Diff.{resolveUploads, resolveDeletes}
+import s3.website.S3._
+import scala.concurrent.ExecutionContext.fromExecutor
+import java.util.concurrent.Executors.newFixedThreadPool
+import s3.website.model.LocalFile.resolveLocalFiles
+import scala.collection.parallel.ParSeq
+import java.util.concurrent.ExecutorService
+import s3.website.model._
+import s3.website.Implicits._
+import s3.website.model.Update
+import s3.website.model.NewFile
+import s3.website.S3.PushSuccessReport
+import scala.collection.mutable.ArrayBuffer
+import s3.website.CloudFront.{SuccessfulInvalidation, FailedInvalidation, CloudFrontClientProvider, toInvalidationBatches}
+import s3.website.S3.SuccessfulDelete
+import s3.website.CloudFront.SuccessfulInvalidation
+import s3.website.S3.SuccessfulUpload
+import s3.website.CloudFront.FailedInvalidation
+
+object Push {
+
+  def pushSite(
+                implicit site: Site,
+                executor: ExecutionContextExecutor,
+                s3ClientProvider: S3ClientProvider = S3.awsS3Client,
+                cloudFrontClientProvider: CloudFrontClientProvider = CloudFront.awsCloudFrontClient,
+                cloudFrontSleepTimeUnit: TimeUnit = MINUTES
+                ): ExitCode = {
+    println(s"Deploying ${site.rootDirectory}/* to ${site.config.s3_bucket}")
+
+    val errorsOrReports = for {
+      s3Files    <- resolveS3Files.right
+      localFiles <- resolveLocalFiles.right
+    } yield {
+      val redirects = Redirect.resolveRedirects
+      val deleteReports: PushReports = resolveDeletes(localFiles, s3Files, redirects)
+        .map { s3File => new S3() delete s3File.s3Key }
+        .map { Right(_) /* To make delete reports type-compatible with upload reports */ }
+        .par
+      deleteReports.tasksupport_=(new ForkJoinTaskSupport(new ForkJoinPool(site.config.concurrency_level)))
+      val uploadReports: PushReports = (redirects.toStream.map(Right(_)) ++ resolveUploads(localFiles, s3Files))
+        .map { errorOrUpload => errorOrUpload.right.map(new S3() upload ) }
+        .par
+      uploadReports.tasksupport_=(new ForkJoinTaskSupport(new ForkJoinPool(site.config.concurrency_level)))
+      uploadReports ++ deleteReports
+    }
+    val errorsOrFinishedPushOps: Either[Error, FinishedPushOperations] = errorsOrReports.right map {
+      uploadReports => awaitForUploads(uploadReports)
+    }
+    val invalidationSucceeded = invalidateCloudFrontItems(errorsOrFinishedPushOps)
+    
+    afterPushFinished(errorsOrFinishedPushOps, invalidationSucceeded)
+  }
+  
+  def invalidateCloudFrontItems
+    (errorsOrFinishedPushOps: Either[Error, FinishedPushOperations])
+    (implicit config: Config, cloudFrontClientProvider: CloudFrontClientProvider, cloudFrontSleepTimeUnit: TimeUnit): Option[InvalidationSucceeded] = {
+    config.cloudfront_distribution_id.map {
+      distributionId =>
+        val pushSuccessReports = errorsOrFinishedPushOps.fold(
+          errors => Nil,
+          finishedPushOps => {
+            finishedPushOps.map {
+              ops =>
+                for {
+                  failedOrSucceededPushes <- ops.right
+                  successfulPush <- failedOrSucceededPushes.right
+                } yield successfulPush
+            }.foldLeft(Seq(): Seq[PushSuccessReport]) {
+              (reports, failOrSucc) =>
+                failOrSucc.fold(
+                  _ => reports,
+                  (pushSuccessReport: PushSuccessReport) => reports :+ pushSuccessReport
+                )
+            }
+          }
+        )
+        val invalidationResults: Seq[Either[FailedInvalidation, SuccessfulInvalidation]] =
+          toInvalidationBatches(pushSuccessReports) map (new CloudFront().invalidate(_, distributionId))
+        if (invalidationResults.exists(_.isLeft))
+          false // If one of the invalidations failed, mark the whole process as failed
+        else
+          true
+    }
+  }
+
+  type InvalidationSucceeded = Boolean
+
+  def afterPushFinished(errorsOrFinishedUploads: Either[Error, FinishedPushOperations], invalidationSucceeded: Option[Boolean])(implicit config: Config): ExitCode = {
+    errorsOrFinishedUploads.right.foreach { finishedUploads =>
+      val pushCounts = pushCountsToString(resolvePushCounts(finishedUploads))
+      println(s"$pushCounts")
+      println(s"Go visit: http://${config.s3_bucket}.${config.s3_endpoint.s3WebsiteHostname}")
+    }
+    errorsOrFinishedUploads.left foreach (err => println(s"Failed to push the site: ${err.message}"))
+    errorsOrFinishedUploads.fold(
+      _ => 1,
+      finishedUploads => finishedUploads.foldLeft(0) { (memo, finishedUpload) =>
+        memo + finishedUpload.fold(
+          (error: Error) => 1,
+          (failedOrSucceededUpload: Either[PushFailureReport, PushSuccessReport]) =>
+            if (failedOrSucceededUpload.isLeft) 1 else 0
+        )
+      } min 1
+    ) max invalidationSucceeded.fold(0)(allInvalidationsSucceeded =>
+      if (allInvalidationsSucceeded) 0 else 1
+    )
+  }
+
+  def awaitForUploads(uploadReports: PushReports)(implicit executor: ExecutionContextExecutor): FinishedPushOperations =
+    uploadReports map (_.right.map {
+      rep => Await.result(rep, 1 day)
+    })
+
+  def resolvePushCounts(implicit finishedOperations: FinishedPushOperations) = finishedOperations.foldLeft(PushCounts()) {
+    (counts: PushCounts, uploadReport) => uploadReport.fold(
+      (error: model.Error) => counts.copy(failures = counts.failures + 1),
+      failureOrSuccess => failureOrSuccess.fold(
+        (failureReport: PushFailureReport) => counts.copy(failures = counts.failures + 1),
+        (successReport: PushSuccessReport) => successReport match {
+          case SuccessfulUpload(upload) => upload.uploadType match {
+            case NewFile  => counts.copy(newFiles = counts.newFiles + 1)
+            case Update   => counts.copy(updates = counts.updates + 1)
+            case Redirect => counts.copy(redirects = counts.redirects + 1)
+          }
+          case SuccessfulDelete(_) => counts.copy(deletes = counts.deletes + 1)
+        }
+      )
+    )
+  }
+
+  def pushCountsToString(pushCounts: PushCounts): String =
+    pushCounts match {
+      case PushCounts(updates, newFiles, failures, redirects, deletes)
+        if updates == 0 && newFiles == 0 && failures == 0 && redirects == 0 && deletes == 0 =>
+          "There was nothing to push."
+      case PushCounts(updates, newFiles, failures, redirects, deletes) =>
+        val reportClauses: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer()
+        if (updates > 0)   reportClauses += s"Updated $updates file(s)."
+        if (newFiles > 0)  reportClauses += s"Created $newFiles file(s)."
+        if (failures > 0)  reportClauses += s"$failures operation(s) failed." // This includes both failed uploads and deletes.
+        if (redirects > 0) reportClauses += s"Applied $redirects redirect(s)."
+        if (deletes > 0)   reportClauses += s"Deleted $deletes files(s)."
+        reportClauses.mkString(" ")
+    }
+
+  case class PushCounts(
+                         updates: Int = 0, 
+                         newFiles: Int = 0, 
+                         failures: Int = 0, 
+                         redirects: Int = 0, 
+                         deletes: Int = 0
+                         )
+  type FinishedPushOperations = ParSeq[Either[model.Error, Either[PushFailureReport, PushSuccessReport]]]
+  type PushReports = ParSeq[Either[model.Error, Future[Either[PushFailureReport, PushSuccessReport]]]]
+  case class PushResult(threadPool: ExecutorService, uploadReports: PushReports)
+  type ExitCode = Int
+
+  trait CliArgs {
+    import com.lexicalscope.jewel.cli.Option
+
+    @Option def site: String
+    @Option(longName = Array("config-dir")) def configDir: String
+
+  }
+
+  def main(args: Array[String]) {
+    val cliArgs = CliFactory.parseArguments(classOf[CliArgs], args:_*)
+    val errorOrPushStatus = loadSite(cliArgs.configDir + "/s3_website.yml", cliArgs.site)
+      .right
+      .map {
+      implicit site =>
+        val threadPool = newFixedThreadPool(site.config.concurrency_level)
+        implicit val executor = fromExecutor(threadPool)
+        val pushStatus = pushSite
+        threadPool.shutdownNow()
+        pushStatus
+    }
+    errorOrPushStatus.left foreach (err => println(s"Could not load the site: ${err.message}"))
+    System.exit(errorOrPushStatus.fold(_ => 1, pushStatus => pushStatus))
+  }
+}

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

@@ -0,0 +1,12 @@
+package s3.website
+
+object Ruby {
+  lazy val rubyRuntime = org.jruby.Ruby.newInstance() // Instantiate heavy object
+
+  def rubyRegexMatches(text: String, regex: String) =
+    rubyRuntime.evalScriptlet(
+      s"""
+         !!Regexp.new('$regex').match('$text') # Use !! to force a boolean conversion
+       """
+    ).toJava(classOf[Boolean]).asInstanceOf[Boolean]
+}

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

@@ -0,0 +1,139 @@
+package s3.website
+
+import s3.website.model._
+import com.amazonaws.services.s3.{AmazonS3, AmazonS3Client}
+import com.amazonaws.auth.BasicAWSCredentials
+import com.amazonaws.services.s3.model._
+import scala.collection.JavaConversions._
+import scala.util.Try
+import com.amazonaws.AmazonClientException
+import scala.concurrent.{ExecutionContextExecutor, Future}
+import s3.website.S3._
+import com.amazonaws.services.s3.model.StorageClass.ReducedRedundancy
+import s3.website.S3.SuccessfulUpload
+import s3.website.S3.FailedUpload
+import scala.util.Failure
+import scala.Some
+import s3.website.model.IOError
+import scala.util.Success
+import s3.website.model.UserError
+
+class S3(implicit s3Client: S3ClientProvider) {
+
+  def upload(upload: Upload with UploadTypeResolved)(implicit config: Config, executor: ExecutionContextExecutor): Future[Either[FailedUpload, SuccessfulUpload]] =
+    Future {
+      s3Client(config) putObject toPutObjectRequest(upload)
+      val report = SuccessfulUpload(upload)
+      println(report.reportMessage)
+      Right(report)
+    } recover {
+      case error =>
+        val report = FailedUpload(upload.s3Key, error)
+        println(report.reportMessage)
+        Left(report)
+    }
+
+  def delete(s3Key: String)(implicit config: Config, executor: ExecutionContextExecutor): Future[Either[FailedDelete, SuccessfulDelete]] =
+    Future {
+      s3Client(config) deleteObject(config.s3_bucket, s3Key)
+      val report = SuccessfulDelete(s3Key)
+      println(report.reportMessage)
+      Right(report)
+    } recover {
+      case error =>
+        val report = FailedDelete(s3Key, error)
+        println(report.reportMessage)
+        Left(report)
+    }
+
+  def toPutObjectRequest(upload: Upload)(implicit config: Config) =
+    upload.essence.fold(
+      redirect => {
+        val req = new PutObjectRequest(config.s3_bucket, upload.s3Key, redirect.redirectTarget)
+        req.setMetadata({
+          val md = new ObjectMetadata()
+          md.setContentLength(0) // Otherwise the AWS SDK will log a warning
+          /*
+           * Instruct HTTP clients to always re-check the redirect. The 301 status code may override this, though.
+           * This is for the sake of simplicity.
+           */
+          md.setCacheControl("max-age=0, no-cache")
+          md
+        })
+        req
+      },
+      uploadBody => {
+        val md = new ObjectMetadata()
+        md setContentLength uploadBody.contentLength
+        md setContentType uploadBody.contentType
+        uploadBody.contentEncoding foreach md.setContentEncoding
+        uploadBody.maxAge foreach (seconds => md.setCacheControl(s"max-age=$seconds"))
+        val req = new PutObjectRequest(config.s3_bucket, upload.s3Key, uploadBody.openInputStream(), md)
+        config.s3_reduced_redundancy.filter(_ == true) foreach (_ => req setStorageClass ReducedRedundancy)
+        req
+      }
+    )
+}
+
+object S3 {
+  def awsS3Client(config: Config) = new AmazonS3Client(new BasicAWSCredentials(config.s3_id, config.s3_secret))
+
+  def resolveS3Files(implicit config: Config, s3ClientProvider: S3ClientProvider): Either[Error, Stream[S3File]] = Try {
+    objectSummaries()
+  } match {
+    case Success(remoteFiles) =>
+      Right(remoteFiles)
+    case Failure(error) if error.isInstanceOf[AmazonClientException] =>
+      Left(UserError(error.getMessage))
+    case Failure(error) =>
+      Left(IOError(error))
+  }
+
+  def objectSummaries(nextMarker: Option[String] = None)(implicit config: Config, s3ClientProvider: S3ClientProvider): Stream[S3File] = {
+    val objects: ObjectListing = s3ClientProvider(config).listObjects({
+      val req = new ListObjectsRequest()
+      req.setBucketName(config.s3_bucket)
+      nextMarker.foreach(req.setMarker)
+      req
+    })
+    val summaries = (objects.getObjectSummaries map (S3File(_))).toStream
+    if (objects.isTruncated)
+      summaries #::: objectSummaries(Some(objects.getNextMarker)) // Call the next Get Bucket request lazily
+    else
+      summaries
+  }
+
+  sealed trait PushItemReport {
+    def reportMessage: String
+  }
+
+  sealed trait PushFailureReport extends PushItemReport
+  sealed trait PushSuccessReport extends PushItemReport {
+    def s3Key: String
+  }
+
+  case class SuccessfulUpload(upload: Upload with UploadTypeResolved) extends PushSuccessReport {
+    def reportMessage =
+      upload.uploadType match {
+        case NewFile  => s"Created ${upload.s3Key}"
+        case Update   => s"Updated ${upload.s3Key}"
+        case Redirect => s"Redirecting ${upload.essence.left.get.key} to ${upload.essence.left.get.redirectTarget}"
+      }
+
+    def s3Key = upload.s3Key
+  }
+
+  case class SuccessfulDelete(s3Key: String) extends PushSuccessReport {
+    def reportMessage = s"Deleted $s3Key"
+  }
+
+  case class FailedUpload(s3Key: String, error: Throwable) extends PushFailureReport {
+    def reportMessage = s"Failed to upload $s3Key (${error.getMessage})"
+  }
+
+  case class FailedDelete(s3Key: String, error: Throwable) extends PushFailureReport {
+    def reportMessage = s"Failed to delete $s3Key (${error.getMessage})"
+  }
+
+  type S3ClientProvider = (Config) => AmazonS3
+}

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

@@ -0,0 +1,152 @@
+package s3.website.model
+
+import scala.util.{Failure, Try}
+import scala.collection.JavaConversions._
+import s3.website.Ruby.rubyRuntime
+
+case class Config(
+  s3_id:                      String,
+  s3_secret:                  String,
+  s3_bucket:                  String,
+  s3_endpoint:                S3Endpoint,
+  max_age:                    Option[Either[Int, Map[String, Int]]],
+  gzip:                       Option[Either[Boolean, Seq[String]]],
+  gzip_zopfli:                Option[Boolean],
+  ignore_on_server:           Option[Either[String, Seq[String]]],
+  exclude_from_upload:        Option[Either[String, Seq[String]]],
+  s3_reduced_redundancy:      Option[Boolean],
+  cloudfront_distribution_id: Option[String],
+  cloudfront_invalidate_root: Option[Boolean],
+  redirects:                  Option[Map[String, String]],
+  concurrency_level:          Int
+)
+
+object Config {
+  def loadOptionalBooleanOrStringSeq(key: String)(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[Either[Boolean, Seq[String]]]] = {
+    val yamlValue = for {
+      optionalValue <- loadOptionalValue(key)
+    } yield {
+      Right(optionalValue.map {
+        case value if value.isInstanceOf[Boolean] => Left(value.asInstanceOf[Boolean])
+        case value if value.isInstanceOf[java.util.List[_]] => Right(value.asInstanceOf[java.util.List[String]].toIndexedSeq)
+      })
+    }
+
+    yamlValue getOrElse Left(UserError(s"The key $key has to have a boolean or [string] value"))
+  }
+
+  def loadOptionalStringOrStringSeq(key: String)(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[Either[String, Seq[String]]]] = {
+    val yamlValue = for {
+      valueOption <- loadOptionalValue(key)
+    } yield {
+      Right(valueOption.map {
+        case value if value.isInstanceOf[String] => Left(value.asInstanceOf[String])
+        case value if value.isInstanceOf[java.util.List[_]] => Right(value.asInstanceOf[java.util.List[String]].toIndexedSeq)
+      })
+    }
+
+    yamlValue getOrElse Left(UserError(s"The key $key has to have a string or [string] value"))
+  }
+
+  def loadMaxAge(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[Either[Int, Map[String, Int]]]] = {
+    val key = "max_age"
+    val yamlValue = for {
+      maxAgeOption <- loadOptionalValue(key)
+    } yield {
+      Right(maxAgeOption.map {
+        case maxAge if maxAge.isInstanceOf[Int] => Left(maxAge.asInstanceOf[Int])
+        case maxAge if maxAge.isInstanceOf[java.util.Map[_,_]] => Right(maxAge.asInstanceOf[java.util.Map[String,Int]].toMap)
+      })
+    }
+
+    yamlValue getOrElse Left(UserError(s"The key $key has to have an int or (string -> int) value"))
+  }
+
+  def loadEndpoint(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[S3Endpoint]] =
+    loadOptionalString("s3_endpoint").right flatMap { endpointString =>
+      endpointString.map(S3Endpoint.forString) match {
+        case Some(Right(endpoint)) => Right(Some(endpoint))
+        case Some(Left(endpointError)) => Left(endpointError)
+        case None => Right(None)
+      }
+    }
+
+  def loadRedirects(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[Map[String, String]]] = {
+    val key = "redirects"
+    val yamlValue = for {
+      redirectsOption <- loadOptionalValue(key)
+      redirects <- Try(redirectsOption.map(_.asInstanceOf[java.util.Map[String,String]].toMap))
+    } yield Right(redirects)
+
+    yamlValue getOrElse Left(UserError(s"The key $key has to have an int or (string -> int) value"))
+  }
+
+  def loadRequiredString(key: String)(implicit unsafeYaml: UnsafeYaml): Either[Error, String] = {
+    val yamlValue = for {
+      valueOption <- loadOptionalValue(key)
+      stringValue <- Try(valueOption.asInstanceOf[Option[String]].get)
+    } yield {
+      Right(stringValue)
+    }
+
+    yamlValue getOrElse {
+      Left(UserError(s"The key $key has to have a string value"))
+    }
+  }
+
+  def loadOptionalString(key: String)(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[String]] = {
+    val yamlValueOption = for {
+      valueOption <- loadOptionalValue(key)
+      optionalString <- Try(valueOption.asInstanceOf[Option[String]])
+    } yield {
+      Right(optionalString)
+    }
+
+    yamlValueOption getOrElse {
+      Left(UserError(s"The key $key has to have a string value"))
+    }
+  }
+
+  def loadOptionalBoolean(key: String)(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[Boolean]] = {
+    val yamlValueOption = for {
+      valueOption <- loadOptionalValue(key)
+      optionalBoolean <- Try(valueOption.asInstanceOf[Option[Boolean]])
+    } yield {
+      Right(optionalBoolean)
+    }
+
+    yamlValueOption getOrElse {
+      Left(UserError(s"The key $key has to have a boolean value"))
+    }
+  }
+
+  def loadOptionalInt(key: String)(implicit unsafeYaml: UnsafeYaml): Either[Error, Option[Int]] = {
+    val yamlValueOption = for {
+      valueOption <- loadOptionalValue(key)
+      optionalInt <- Try(valueOption.asInstanceOf[Option[Int]])
+    } yield {
+      Right(optionalInt)
+    }
+
+    yamlValueOption getOrElse {
+      Left(UserError(s"The key $key has to have an integer value"))
+    }
+  }
+
+  def loadOptionalValue(key: String)(implicit unsafeYaml: UnsafeYaml): Try[Option[_]] =
+    Try {
+      unsafeYaml.yamlObject.asInstanceOf[java.util.Map[String, _]].toMap get key
+    }
+
+  def erbEval(erbString: String): Try[String] = Try {
+    val erbStringWithoutComments = erbString.replaceAll("#.*", "")
+    rubyRuntime.evalScriptlet(
+      s"""
+        require 'erb'
+        ERB.new("$erbStringWithoutComments").result
+      """
+    ).asJavaString()
+  }
+
+  case class UnsafeYaml(yamlObject: AnyRef)
+}

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

@@ -0,0 +1,22 @@
+package s3.website.model
+
+case class S3Endpoint(
+  s3WebsiteHostname: String,
+  s3Hostname: String
+)
+
+object S3Endpoint {
+  val defaultEndpoint = S3Endpoint("s3-website-us-east-1.amazonaws.com", "s3.amazonaws.com")
+
+  def forString(locationConstraint: String): Either[UserError, S3Endpoint] = locationConstraint match {
+    case "EU" | "eu-west-1" => Right(S3Endpoint("s3-website-eu-west-1.amazonaws.com",      "s3-eu-west-1.amazonaws.com"))
+    case "us-east-1" =>        Right(defaultEndpoint)
+    case "us-west-1" =>        Right(S3Endpoint("s3-website-us-west-1.amazonaws.com",      "s3-us-west-1.amazonaws.com"))
+    case "us-west-2" =>        Right(S3Endpoint("s3-website-us-west-2.amazonaws.com",      "s3-us-west-2.amazonaws.com"))
+    case "ap-southeast-1" =>   Right(S3Endpoint("s3-website-ap-southeast-1.amazonaws.com", "s3-ap-southeast-1.amazonaws.com"))
+    case "ap-southeast-2" =>   Right(S3Endpoint("s3-website-ap-southeast-2.amazonaws.com", "s3-ap-southeast-2.amazonaws.com"))
+    case "ap-northeast-1" =>   Right(S3Endpoint("s3-website-ap-northeast-1.amazonaws.com", "s3-ap-northeast-1.amazonaws.com"))
+    case "sa-east-1" =>        Right(S3Endpoint("s3-website-sa-east-1.amazonaws.com",      "s3-sa-east-1.amazonaws.com"))
+    case _ =>                  Left(UserError(s"Unrecognised endpoint: $locationConstraint"))
+  }
+}

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

@@ -0,0 +1,68 @@
+package s3.website.model
+
+import java.io.File
+import scala.util.{Failure, Success, Try}
+import org.yaml.snakeyaml.Yaml
+import s3.website.model.Config._
+import scala.io.Source.fromFile
+import scala.language.postfixOps
+
+case class Site(rootDirectory: String, config: Config) {
+  def resolveS3Key(file: File) = file.getAbsolutePath.replace(rootDirectory, "").replaceFirst("^/", "")
+}
+
+object Site {
+  def loadSite(yamlConfigPath: String, siteRootDirectory: String): Either[Error, Site] = {
+    val yamlObjectTry = for {
+      yamlString <- Try(fromFile(new File(yamlConfigPath)).mkString)
+      yamlWithErbEvaluated <- erbEval(yamlString)
+      yamlObject <- Try(new Yaml() load yamlWithErbEvaluated)
+    } yield yamlObject
+    yamlObjectTry match {
+      case Success(yamlObject) =>
+        implicit val unsafeYaml = UnsafeYaml(yamlObject)
+        val config: Either[Error, Config] = for {
+          s3_id <- loadRequiredString("s3_id").right
+          s3_secret <- loadRequiredString("s3_secret").right
+          s3_bucket <- loadRequiredString("s3_bucket").right
+          s3_endpoint <- loadEndpoint.right
+          max_age <- loadMaxAge.right
+          gzip <- loadOptionalBooleanOrStringSeq("gzip").right
+          gzip_zopfli <- loadOptionalBoolean("gzip_zopfli").right
+          extensionless_mime_type <- loadOptionalString("extensionless_mime_type").right
+          ignore_on_server <- loadOptionalStringOrStringSeq("ignore_on_server").right
+          exclude_from_upload <- loadOptionalStringOrStringSeq("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
+          concurrency_level <- loadOptionalInt("concurrency_level").right
+          redirects <- loadRedirects.right
+        } yield {
+          gzip_zopfli.foreach(_ => println("zopfli is not currently supported"))
+          extensionless_mime_type.foreach(_ => println(
+            s"Ignoring the extensionless_mime_type setting in $yamlConfigPath. Counting on Apache Tika to infer correct mime types.")
+          )
+          Config(
+            s3_id,
+            s3_secret,
+            s3_bucket,
+            s3_endpoint getOrElse S3Endpoint.defaultEndpoint,
+            max_age,
+            gzip,
+            gzip_zopfli,
+            ignore_on_server = ignore_on_server,
+            exclude_from_upload = exclude_from_upload,
+            s3_reduced_redundancy,
+            cloudfront_distribution_id,
+            cloudfront_invalidate_root,
+            redirects,
+            concurrency_level.fold(20)(_ max 20) // At minimum, run 20 concurrent operations
+          )
+        }
+
+        config.right.map(Site(siteRootDirectory, _))
+      case Failure(error) =>
+        Left(IOError(error))
+    }
+  }
+}

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

@@ -0,0 +1,11 @@
+package s3.website.model
+
+trait Error {
+  def message: String
+}
+
+case class UserError(message: String) extends Error
+
+case class IOError(exception: Throwable) extends Error {
+  def message = exception.getMessage
+}