Overhaul async execution infrastructure in Jib (#1771)

jib-core/src/main/java/com/google/cloud/tools/jib/api/Containerizer.java

@@ -17,6 +17,7 @@
 package com.google.cloud.tools.jib.api;
 // TODO: Move to com.google.cloud.tools.jib once that package is cleaned up.
 
+import com.google.cloud.tools.jib.builder.steps.BuildResult;
 import com.google.cloud.tools.jib.builder.steps.StepsRunner;
 import com.google.cloud.tools.jib.configuration.BuildConfiguration;
 import com.google.cloud.tools.jib.configuration.ImageConfiguration;
@@ -31,6 +32,7 @@
 import java.util.HashSet;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.Consumer;
@@ -67,18 +69,7 @@ public static Containerizer to(RegistryImage registryImage) {
             .build();
 
     Function<BuildConfiguration, StepsRunner> stepsRunnerFactory =
-        buildConfiguration ->
-            StepsRunner.begin(buildConfiguration)
-                .retrieveTargetRegistryCredentials()
-                .authenticatePush()
-                .pullBaseImage()
-                .pullAndCacheBaseImageLayers()
-                .pushBaseImageLayers()
-                .buildAndCacheApplicationLayers()
-                .buildImage()
-                .pushContainerConfiguration()
-                .pushApplicationLayers()
-                .pushImage();
+        buildConfiguration -> StepsRunner.begin(buildConfiguration).registryPushSteps();
 
     return new Containerizer(
         DESCRIPTION_FOR_DOCKER_REGISTRY, imageConfiguration, stepsRunnerFactory, true);
@@ -101,12 +92,7 @@ public static Containerizer to(DockerDaemonImage dockerDaemonImage) {
 
     Function<BuildConfiguration, StepsRunner> stepsRunnerFactory =
         buildConfiguration ->
-            StepsRunner.begin(buildConfiguration)
-                .pullBaseImage()
-                .pullAndCacheBaseImageLayers()
-                .buildAndCacheApplicationLayers()
-                .buildImage()
-                .loadDocker(dockerClientBuilder.build());
+            StepsRunner.begin(buildConfiguration).dockerLoadSteps(dockerClientBuilder.build());
 
     return new Containerizer(
         DESCRIPTION_FOR_DOCKER_DAEMON, imageConfiguration, stepsRunnerFactory, false);
@@ -124,12 +110,7 @@ public static Containerizer to(TarImage tarImage) {
 
     Function<BuildConfiguration, StepsRunner> stepsRunnerFactory =
         buildConfiguration ->
-            StepsRunner.begin(buildConfiguration)
-                .pullBaseImage()
-                .pullAndCacheBaseImageLayers()
-                .buildAndCacheApplicationLayers()
-                .buildImage()
-                .writeTarFile(tarImage.getOutputFile());
+            StepsRunner.begin(buildConfiguration).tarBuildSteps(tarImage.getOutputFile());
 
     return new Containerizer(
         DESCRIPTION_FOR_TARBALL, imageConfiguration, stepsRunnerFactory, false);
@@ -303,9 +284,8 @@ Path getApplicationLayersCacheDirectory() throws CacheDirectoryCreationException
     if (applicationLayersCacheDirectory == null) {
       // Uses a temporary directory if application layers cache directory is not set.
       try {
-        Path temporaryDirectory = Files.createTempDirectory(null);
-        temporaryDirectory.toFile().deleteOnExit();
-        this.applicationLayersCacheDirectory = temporaryDirectory;
+        applicationLayersCacheDirectory = Files.createTempDirectory(null);
+        applicationLayersCacheDirectory.toFile().deleteOnExit();
 
       } catch (IOException ex) {
         throw new CacheDirectoryCreationException(ex);
@@ -338,7 +318,8 @@ ImageConfiguration getImageConfiguration() {
     return imageConfiguration;
   }
 
-  StepsRunner createStepsRunner(BuildConfiguration buildConfiguration) {
-    return stepsRunnerFactory.apply(buildConfiguration);
+  BuildResult run(BuildConfiguration buildConfiguration)
+      throws ExecutionException, InterruptedException {
+    return stepsRunnerFactory.apply(buildConfiguration).run();
   }
 }

jib-core/src/main/java/com/google/cloud/tools/jib/api/JibContainerBuilder.java

@@ -475,7 +475,7 @@ JibContainer containerize(
 
     try (TimerEventDispatcher ignored =
         new TimerEventDispatcher(eventHandlers, containerizer.getDescription())) {
-      BuildResult result = containerizer.createStepsRunner(buildConfiguration).run();
+      BuildResult result = containerizer.run(buildConfiguration);
       return new JibContainer(result.getImageDigest(), result.getImageId());
 
     } catch (ExecutionException ex) {

jib-core/src/main/java/com/google/cloud/tools/jib/builder/steps/AuthenticatePushStep.java

@@ -19,19 +19,13 @@
 import com.google.cloud.tools.jib.api.Credential;
 import com.google.cloud.tools.jib.api.InsecureRegistryException;
 import com.google.cloud.tools.jib.api.RegistryException;
-import com.google.cloud.tools.jib.async.AsyncDependencies;
-import com.google.cloud.tools.jib.async.AsyncStep;
-import com.google.cloud.tools.jib.async.NonBlockingSteps;
 import com.google.cloud.tools.jib.builder.ProgressEventDispatcher;
 import com.google.cloud.tools.jib.builder.TimerEventDispatcher;
 import com.google.cloud.tools.jib.configuration.BuildConfiguration;
 import com.google.cloud.tools.jib.http.Authorization;
 import com.google.cloud.tools.jib.registry.RegistryAuthenticator;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
 import java.io.IOException;
 import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
 import javax.annotation.Nullable;
 
 /**
@@ -40,42 +34,26 @@
  * @see <a
  *     href="https://docs.docker.com/registry/spec/auth/token/">https://docs.docker.com/registry/spec/auth/token/</a>
  */
-class AuthenticatePushStep implements AsyncStep<Authorization>, Callable<Authorization> {
+class AuthenticatePushStep implements Callable<Authorization> {
 
-  private static final String DESCRIPTION = "Authenticating with push to %s";
+  private static final String DESCRIPTION = "Authenticating push to %s";
 
   private final BuildConfiguration buildConfiguration;
   private final ProgressEventDispatcher.Factory progressEventDispatcherFactory;
-
-  private final RetrieveRegistryCredentialsStep retrieveTargetRegistryCredentialsStep;
-
-  private final ListenableFuture<Authorization> listenableFuture;
+  private final Credential registryCredential;
 
   AuthenticatePushStep(
-      ListeningExecutorService listeningExecutorService,
       BuildConfiguration buildConfiguration,
       ProgressEventDispatcher.Factory progressEventDispatcherFactory,
-      RetrieveRegistryCredentialsStep retrieveTargetRegistryCredentialsStep) {
+      Credential registryCredential) {
     this.buildConfiguration = buildConfiguration;
     this.progressEventDispatcherFactory = progressEventDispatcherFactory;
-    this.retrieveTargetRegistryCredentialsStep = retrieveTargetRegistryCredentialsStep;
-
-    listenableFuture =
-        AsyncDependencies.using(listeningExecutorService)
-            .addStep(retrieveTargetRegistryCredentialsStep)
-            .whenAllSucceed(this);
-  }
-
-  @Override
-  public ListenableFuture<Authorization> getFuture() {
-    return listenableFuture;
+    this.registryCredential = registryCredential;
   }
 
   @Override
   @Nullable
-  public Authorization call() throws ExecutionException, IOException, RegistryException {
-    Credential registryCredential = NonBlockingSteps.get(retrieveTargetRegistryCredentialsStep);
-
+  public Authorization call() throws IOException, RegistryException {
     String registry = buildConfiguration.getTargetImageConfiguration().getImageRegistry();
     try (ProgressEventDispatcher ignored =
             progressEventDispatcherFactory.create("authenticating push to " + registry, 1);