CHE-5901: Rework SPI to simplify an infrastructure implementation (eclipse-che#6047)

Rework SPI to simplify an infrastructure implementation.
Move installers evaluation, environment recipe content
downloading to SPI level from infra implementation level.
Treat a machine with wsagent server dev machine instead of
checking wsagent installer only.
Improve code coverage.
Fix downloading of an environment recipe content from a Github
gist.
Signed-off-by: Oleksandr Garagatyi <ogaragat@redhat.com>

Author: Oleksandr Garagatyi

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/DockerInternalRuntime.java

@@ -33,6 +33,7 @@
 import org.eclipse.che.api.core.notification.EventService;
 import org.eclipse.che.api.workspace.server.DtoConverter;
 import org.eclipse.che.api.workspace.server.URLRewriter;
+import org.eclipse.che.api.workspace.server.WsAgentMachineFinderUtil;
 import org.eclipse.che.api.workspace.server.hc.ServerCheckerFactory;
 import org.eclipse.che.api.workspace.server.hc.ServersReadinessChecker;
 import org.eclipse.che.api.workspace.server.model.impl.MachineImpl;
@@ -294,7 +295,7 @@ void checkServers() throws InfrastructureException {
 
   private void startMachine(String name, DockerContainerConfig containerConfig)
       throws InfrastructureException, InterruptedException {
-    InternalMachineConfig machineCfg = getContext().getMachineConfigs().get(name);
+    InternalMachineConfig machineCfg = getContext().getEnvironment().getMachines().get(name);
 
     DockerMachine machine =
         containerStarter.startContainer(
@@ -441,18 +442,24 @@ machineName, getContext().getIdentity().getWorkspaceId(), machine.getContainer()
    *
    * @param machines the active machines map
    */
-  private void snapshotMachines(Map<String, DockerMachine> machines) {
+  private void snapshotMachines(Map<String, DockerMachine> machines)
+      throws InternalInfrastructureException {
     List<SnapshotImpl> newSnapshots = new ArrayList<>();
     final RuntimeIdentity identity = getContext().getIdentity();
-    String devMachineName = getContext().getDevMachineName();
+    // TODO do we need dev machine flag at all?
+    String devMachineName =
+        WsAgentMachineFinderUtil.getWsAgentServerMachine(getContext().getEnvironment())
+            .orElseThrow(
+                () -> new InternalInfrastructureException("Machine with wsagent is not found"));
+
     for (Map.Entry<String, DockerMachine> dockerMachineEntry : machines.entrySet()) {
       SnapshotImpl snapshot =
           SnapshotImpl.builder()
               .generateId()
               .setType("docker") //TODO: do we need that at all?
               .setWorkspaceId(identity.getWorkspaceId())
               .setDescription(identity.getEnvName())
-              .setDev(dockerMachineEntry.getKey().equals(devMachineName))
+              .setDev(devMachineName.equals(dockerMachineEntry.getKey()))
               .setEnvName(identity.getEnvName())
               .setMachineName(dockerMachineEntry.getKey())
               .useCurrentCreationDate()

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/DockerRuntimeContext.java

@@ -22,11 +22,9 @@
 import javax.ws.rs.core.UriBuilder;
 import javax.ws.rs.core.UriBuilderException;
 import org.eclipse.che.api.core.ValidationException;
-import org.eclipse.che.api.core.model.workspace.config.Environment;
 import org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity;
-import org.eclipse.che.api.installer.server.InstallerRegistry;
-import org.eclipse.che.api.workspace.server.Utils;
 import org.eclipse.che.api.workspace.server.spi.InfrastructureException;
+import org.eclipse.che.api.workspace.server.spi.InternalEnvironment;
 import org.eclipse.che.api.workspace.server.spi.InternalInfrastructureException;
 import org.eclipse.che.api.workspace.server.spi.RuntimeContext;
 import org.eclipse.che.plugin.docker.client.json.ContainerListEntry;
@@ -47,7 +45,6 @@ public class DockerRuntimeContext extends RuntimeContext {
 
   private final DockerEnvironment dockerEnvironment;
   private final List<String> orderedContainers;
-  private final String devMachineName;
   private final String websocketEndpointBase;
   private final DockerRuntimeFactory runtimeFactory;
   private final DockerContainers containers;
@@ -58,19 +55,17 @@ public class DockerRuntimeContext extends RuntimeContext {
   public DockerRuntimeContext(
       @Assisted DockerRuntimeInfrastructure infrastructure,
       @Assisted RuntimeIdentity identity,
-      @Assisted Environment environment,
+      @Assisted InternalEnvironment environment,
       @Assisted DockerEnvironment dockerEnv,
       @Assisted List<String> containersOrder,
-      InstallerRegistry installerRegistry,
       DockerRuntimeFactory runtimeFactory,
       DockerContainers containers,
       DockerSharedPool sharedPool,
       RuntimeConsistencyChecker consistencyChecker,
       @Named("che.websocket.endpoint.base") String websocketEndpointBase)
       throws InfrastructureException, ValidationException {
 
-    super(environment, identity, infrastructure, installerRegistry);
-    this.devMachineName = Utils.getDevMachineName(environment);
+    super(environment, identity, infrastructure);
     this.dockerEnvironment = dockerEnv;
     this.orderedContainers = ImmutableList.copyOf(containersOrder);
     this.websocketEndpointBase = websocketEndpointBase;
@@ -85,11 +80,6 @@ public DockerEnvironment getDockerEnvironment() {
     return dockerEnvironment;
   }
 
-  /** Returns the name of the dev machine. */
-  public String getDevMachineName() {
-    return devMachineName;
-  }
-
   /** Returns the list of the ordered containers, machines must be started in the same order. */
   public List<String> getOrderedContainers() {
     return orderedContainers;
@@ -107,14 +97,15 @@ public URI getOutputChannel() throws InfrastructureException {
 
   @Override
   public DockerInternalRuntime getRuntime() throws InfrastructureException {
+    RuntimeIdentity identity = getIdentity();
     List<ContainerListEntry> runningContainers = containers.find(identity);
     if (runningContainers.isEmpty()) {
       return runtimeFactory.create(this);
     }
 
     DockerInternalRuntime runtime = runtimeFactory.create(this, runningContainers);
     try {
-      consistencyChecker.check(environment, runtime);
+      consistencyChecker.check(getEnvironment(), runtime);
       runtime.checkServers();
     } catch (InfrastructureException | ValidationException x) {
       LOG.warn(

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/DockerRuntimeContextFactory.java

@@ -12,17 +12,17 @@
 
 import java.util.List;
 import org.eclipse.che.api.core.ValidationException;
-import org.eclipse.che.api.core.model.workspace.config.Environment;
 import org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity;
 import org.eclipse.che.api.workspace.server.spi.InfrastructureException;
+import org.eclipse.che.api.workspace.server.spi.InternalEnvironment;
 import org.eclipse.che.workspace.infrastructure.docker.model.DockerEnvironment;
 
 /** Helps to create {@link DockerRuntimeContext} instances. */
 public interface DockerRuntimeContextFactory {
   DockerRuntimeContext create(
       DockerRuntimeInfrastructure infra,
       RuntimeIdentity identity,
-      Environment environment,
+      InternalEnvironment environment,
       DockerEnvironment dockerEnv,
       List<String> containersOrder)
       throws InfrastructureException, ValidationException;

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/DockerRuntimeInfrastructure.java

@@ -18,15 +18,19 @@
 import org.eclipse.che.api.core.model.workspace.config.Environment;
 import org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity;
 import org.eclipse.che.api.core.notification.EventService;
+import org.eclipse.che.api.installer.server.InstallerRegistry;
+import org.eclipse.che.api.workspace.server.RecipeRetriever;
 import org.eclipse.che.api.workspace.server.model.impl.EnvironmentImpl;
 import org.eclipse.che.api.workspace.server.spi.InfrastructureException;
+import org.eclipse.che.api.workspace.server.spi.InternalEnvironment;
 import org.eclipse.che.api.workspace.server.spi.RuntimeInfrastructure;
 import org.eclipse.che.workspace.infrastructure.docker.container.ContainersStartStrategy;
 import org.eclipse.che.workspace.infrastructure.docker.container.DockerContainers;
 import org.eclipse.che.workspace.infrastructure.docker.environment.DockerConfigSourceSpecificEnvironmentParser;
 import org.eclipse.che.workspace.infrastructure.docker.environment.EnvironmentNormalizer;
 import org.eclipse.che.workspace.infrastructure.docker.environment.EnvironmentParser;
 import org.eclipse.che.workspace.infrastructure.docker.environment.EnvironmentValidator;
+import org.eclipse.che.workspace.infrastructure.docker.environment.dockerimage.DockerImageEnvironmentParser;
 import org.eclipse.che.workspace.infrastructure.docker.model.DockerEnvironment;
 
 /**
@@ -52,10 +56,12 @@ public DockerRuntimeInfrastructure(
       InfrastructureProvisioner infrastructureProvisioner,
       EnvironmentNormalizer environmentNormalizer,
       Map<String, DockerConfigSourceSpecificEnvironmentParser> environmentParsers,
-      EventService eventService,
       DockerRuntimeContextFactory contextFactory,
-      DockerContainers containers) {
-    super("docker", environmentParsers.keySet(), eventService);
+      DockerContainers containers,
+      EventService eventService,
+      InstallerRegistry installerRegistry,
+      RecipeRetriever recipeRetriever) {
+    super("docker", environmentParsers.keySet(), eventService, installerRegistry, recipeRetriever);
     this.dockerEnvironmentValidator = dockerEnvironmentValidator;
     this.dockerEnvironmentParser = dockerEnvironmentParser;
     this.startStrategy = startStrategy;
@@ -66,26 +72,36 @@ public DockerRuntimeInfrastructure(
   }
 
   @Override
-  public Environment estimate(Environment environment)
+  public InternalEnvironment estimate(Environment environment)
+      throws ValidationException, InfrastructureException {
+    // workaround that in dockerimage environment image is in location field instead of content
+    if (DockerImageEnvironmentParser.TYPE.equals(environment.getRecipe().getType())
+        && environment.getRecipe().getLocation() != null) {
+      // move image from location to content
+      EnvironmentImpl envCopy = new EnvironmentImpl(environment);
+      envCopy.getRecipe().setContent(environment.getRecipe().getLocation());
+      envCopy.getRecipe().setLocation(null);
+      return super.estimate(envCopy);
+    }
+    return super.estimate(environment);
+  }
+
+  @Override
+  public void internalEstimate(InternalEnvironment environment)
       throws ValidationException, InfrastructureException {
-    // TODO spi: get recipe from non-impl specific code
     DockerEnvironment dockerEnvironment = dockerEnvironmentParser.parse(environment);
     dockerEnvironmentValidator.validate(environment, dockerEnvironment);
     // check that order can be resolved
     startStrategy.order(dockerEnvironment);
     // TODO add an actual estimation of what is missing in the environment
     // memory
     // machines
-
-    return environment;
   }
 
   @Override
-  public DockerRuntimeContext prepare(RuntimeIdentity identity, Environment originEnv)
+  public DockerRuntimeContext prepare(RuntimeIdentity identity, InternalEnvironment environment)
       throws ValidationException, InfrastructureException {
-    // TODO spi: get recipe from non-impl specific code
-    // Copy to be able to change env and protect from env changes by method caller
-    EnvironmentImpl environment = new EnvironmentImpl(originEnv);
+
     DockerEnvironment dockerEnvironment = dockerEnvironmentParser.parse(environment);
     dockerEnvironmentValidator.validate(environment, dockerEnvironment);
 

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/InfrastructureProvisioner.java

@@ -11,8 +11,8 @@
 package org.eclipse.che.workspace.infrastructure.docker;
 
 import org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity;
-import org.eclipse.che.api.workspace.server.model.impl.EnvironmentImpl;
 import org.eclipse.che.api.workspace.server.spi.InfrastructureException;
+import org.eclipse.che.api.workspace.server.spi.InternalEnvironment;
 import org.eclipse.che.workspace.infrastructure.docker.model.DockerEnvironment;
 
 /**
@@ -25,10 +25,11 @@ public interface InfrastructureProvisioner {
    * Modifies environment config and internal environment representation with everything needed for
    * infrastructure of workspace.
    *
-   * @param envConfig configuration of environment
+   * @param environment configuration of environment
    * @param internalEnv internal environment representation
    * @throws InfrastructureException if any error occurs
    */
-  void provision(EnvironmentImpl envConfig, DockerEnvironment internalEnv, RuntimeIdentity identity)
+  void provision(
+      InternalEnvironment environment, DockerEnvironment internalEnv, RuntimeIdentity identity)
       throws InfrastructureException;
 }

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/Labels.java

@@ -18,8 +18,8 @@
 import java.util.regex.Pattern;
 import org.eclipse.che.api.core.model.workspace.config.ServerConfig;
 import org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity;
+import org.eclipse.che.api.workspace.server.model.impl.RuntimeIdentityImpl;
 import org.eclipse.che.api.workspace.server.model.impl.ServerConfigImpl;
-import org.eclipse.che.api.workspace.server.spi.RuntimeIdentityImpl;
 
 /**
  * Helps to convert docker infrastructure entities to docker labels and vise-versa.

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/RuntimeConsistencyChecker.java

@@ -13,15 +13,16 @@
 import java.util.Map;
 import javax.inject.Singleton;
 import org.eclipse.che.api.core.ValidationException;
-import org.eclipse.che.api.core.model.workspace.config.Environment;
-import org.eclipse.che.api.core.model.workspace.config.MachineConfig;
 import org.eclipse.che.api.core.model.workspace.runtime.Machine;
+import org.eclipse.che.api.workspace.server.spi.InternalEnvironment;
+import org.eclipse.che.api.workspace.server.spi.InternalMachineConfig;
 
 /** Checks whether runtime is consistent with its configuration. */
 @Singleton
 class RuntimeConsistencyChecker {
-  void check(Environment environment, DockerInternalRuntime runtime) throws ValidationException {
-    Map<String, ? extends MachineConfig> configs = environment.getMachines();
+  void check(InternalEnvironment environment, DockerInternalRuntime runtime)
+      throws ValidationException {
+    Map<String, InternalMachineConfig> configs = environment.getMachines();
     Map<String, ? extends Machine> machines = runtime.getMachines();
     if (configs.size() != machines.size()) {
       throw new ValidationException(

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/environment/DockerConfigSourceSpecificEnvironmentParser.java

@@ -14,6 +14,7 @@
 import org.eclipse.che.api.core.model.workspace.config.Environment;
 import org.eclipse.che.api.core.model.workspace.config.Recipe;
 import org.eclipse.che.api.workspace.server.spi.InfrastructureException;
+import org.eclipse.che.api.workspace.server.spi.InternalEnvironment;
 import org.eclipse.che.workspace.infrastructure.docker.model.DockerEnvironment;
 
 /**
@@ -33,6 +34,6 @@ public interface DockerConfigSourceSpecificEnvironmentParser {
    * @throws InfrastructureException when parsing fails due to some internal server error or
    *     inability to parse environment due to other reasons
    */
-  DockerEnvironment parse(Environment environment)
+  DockerEnvironment parse(InternalEnvironment environment)
       throws ValidationException, InfrastructureException;
 }

infrastructures/docker/src/main/java/org/eclipse/che/workspace/infrastructure/docker/environment/DockerEnvironmentTypeModule.java

@@ -25,7 +25,11 @@ protected void configure() {
         MapBinder.newMapBinder(
             binder(), String.class, DockerConfigSourceSpecificEnvironmentParser.class);
     envParserMapBinder.addBinding("compose").to(ComposeEnvironmentParser.class);
-    envParserMapBinder.addBinding("dockerfile").to(DockerfileEnvironmentParser.class);
-    envParserMapBinder.addBinding("dockerimage").to(DockerImageEnvironmentParser.class);
+    envParserMapBinder
+        .addBinding(DockerfileEnvironmentParser.TYPE)
+        .to(DockerfileEnvironmentParser.class);
+    envParserMapBinder
+        .addBinding(DockerImageEnvironmentParser.TYPE)
+        .to(DockerImageEnvironmentParser.class);
   }
 }