src/main/scala/s3/website/Push.scala in s3_website-2.7.5 vs src/main/scala/s3/website/Push.scala in s3_website-2.7.6

@@ -81,34 +81,28 @@
                 logger: Logger,
                 pushOptions: PushOptions
                 ): ExitCode = {
     logger.info(s"${Deploy.renderVerb} ${site.rootDirectory}/* to ${site.config.s3_bucket}")
     val s3FilesFuture = resolveS3Files()
-    val redirectsFuture: Redirects = resolveRedirects(s3FilesFuture)
-    val redirectReports: Future[Either[ErrorReport, Seq[Future[PushErrorOrSuccess]]]] =
-      redirectsFuture.map { (errOrRedirects: Either[ErrorReport, Seq[Redirect]]) =>
-        errOrRedirects.right.map(_.filter(_.needsUpload).map(S3 uploadRedirect _))
-      }
+    val redirectsFuture = resolveRedirects(s3FilesFuture)
+    val redirectReports = redirectsFuture.map { errOrRedirects =>
+      errOrRedirects.right.map(_.filter(_.needsUpload).map(S3 uploadRedirect _))
+    }
 
-    val uploadFutures: FutureUploads = resolveUploads(s3FilesFuture)
-    val uploadReports: Future[Either[ErrorReport, Seq[Future[PushErrorOrSuccess]]]] = for {
-      errorOrUploads: Either[ErrorReport, Seq[Upload]] <- uploadFutures
+    val uploadReports = for {
+      errorOrUploads <- resolveUploads(s3FilesFuture)
     } yield errorOrUploads.right.map(_.map(S3 uploadFile _))
 
-    val deleteReports: Future[Either[ErrorReport, Seq[Future[PushErrorOrSuccess]]]] = for {
-      errorOrUploads: Either[ErrorReport, Seq[Upload]] <- uploadFutures
-    } yield {
-      val errorsOrDeleteReports = redirectsFuture.flatMap { (errOrRedirects: Either[ErrorReport, Seq[Redirect]]) =>
-        errOrRedirects.fold(
-          err => Future(Left(err)),
-          redirects => resolveDeletes(s3FilesFuture, redirects)
-        )
-      }.map { (deletes: Either[ErrorReport, Seq[S3Key]]) =>
-        deletes.right.map(keysToDelete => keysToDelete.map(S3 delete _))
-      }
-      Await.result(errorsOrDeleteReports, 1 day)
+    val deleteReports = redirectsFuture flatMap { errOrRedirects =>
+      errOrRedirects.fold(
+        err => Future(Left(err)),
+        redirects => resolveDeletes(s3FilesFuture, redirects)
+      )
+    } map { deletes =>
+      deletes.right.map(keysToDelete => keysToDelete.map(S3 delete _))
     }
+
     val allReports = Future.sequence(redirectReports :: uploadReports :: deleteReports :: Nil) map { reports =>
       reports.foldLeft(Nil: PushReports) { (memo, report: Either[ErrorReport, Seq[Future[PushErrorOrSuccess]]]) =>
         report match {
           case Left(err) =>
             memo :+ Left(err)
@@ -118,11 +112,11 @@
       }
     }
     val finishedPushOps = awaitForResults(Await.result(allReports, 1 day))
     val invalidationSucceeded = invalidateCloudFrontItems(finishedPushOps)
     
-    afterPushFinished(finishedPushOps, invalidationSucceeded)
+    report(finishedPushOps, invalidationSucceeded)
   }
   
   def invalidateCloudFrontItems
     (finishedPushOperations: FinishedPushOperations)
     (implicit config: Config, cloudFrontSettings: CloudFrontSetting, ec: ExecutionContextExecutor, logger: Logger, pushOptions: PushOptions):
@@ -155,10 +149,10 @@
         true
     }
 
   type InvalidationSucceeded = Boolean
 
-  def afterPushFinished(finishedPushOps: FinishedPushOperations, invalidationSucceeded: Option[Boolean])
+  def report(finishedPushOps: FinishedPushOperations, invalidationSucceeded: Option[Boolean])
                        (implicit config: Config, logger: Logger, pushOptions: PushOptions): ExitCode = {
     val pushCounts = resolvePushCounts(finishedPushOps)
     logger.info(s"Summary: ${pushCountsToString(pushCounts)}")
     val pushOpExitCode = finishedPushOps.foldLeft(0) { (memo, finishedUpload) =>
       memo + finishedUpload.fold(