fix(fss): exclude waiting for non-autostartable services and their hard dependencies

fix(fss): exclude waiting for non-autostartable services and their hard dependencies

Author: yitingb

src/main/java/com/aws/greengrass/deployment/KernelUpdateDeploymentTask.java

@@ -29,6 +29,7 @@
 import java.nio.file.Path;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
@@ -89,9 +90,7 @@ private void waitForServicesToStart() {
         Deployment.DeploymentStage stage = deployment.getDeploymentStage();
         DeploymentResult result = null;
         try {
-            List<GreengrassService> servicesToTrack =
-                    kernel.orderedDependencies().stream().filter(GreengrassService::shouldAutoStart)
-                            .filter(o -> !kernel.getMain().equals(o)).collect(Collectors.toList());
+            Set<GreengrassService> servicesToTrack = kernel.findAutoStartableServicesToTrack();
             long mergeTimestamp = kernel.getConfig().lookup("system", "rootpath").getModtime();
 
             logger.atInfo().kv("serviceToTrack", servicesToTrack).kv("mergeTime", mergeTimestamp)

src/main/java/com/aws/greengrass/deployment/activator/DefaultActivator.java

@@ -13,12 +13,9 @@
 import com.aws.greengrass.lifecyclemanager.GreengrassService;
 import com.aws.greengrass.lifecyclemanager.Kernel;
 import com.aws.greengrass.lifecyclemanager.exceptions.ServiceLoadException;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
 import java.util.HashMap;
-import java.util.LinkedList;
 import java.util.Map;
-import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
@@ -82,6 +79,9 @@ public void activate(Map<String, Object> newConfig, Deployment deployment,
 
         try {
             Set<GreengrassService> servicesToTrack = servicesChangeManager.servicesToTrack();
+            // Exclude all non-autoStartable services and their dependers
+            // Find the services which both changed and auto startable
+            servicesToTrack.retainAll(kernel.findAutoStartableServicesToTrack());
             logger.atDebug(MERGE_CONFIG_EVENT_KEY).kv("serviceToTrack", servicesToTrack).kv("mergeTime", mergeTime)
                     .log("Applied new service config. Waiting for services to complete update");
             waitForServicesToStart(servicesToTrack, mergeTime, kernel, totallyCompleteFuture);
@@ -144,10 +144,13 @@ void rollback(DeploymentDocument deploymentDocument, CompletableFuture<Deploymen
             // be expected to still be broken
             Set<GreengrassService> servicesToTrackForRollback = rollbackManager.servicesToTrack();
 
-            // Also don't track services if they have (transitive) hard dependencies on already-broken services
-            Set<GreengrassService> brokenServiceAndDependers
-                    = findServiceDependers(servicesToTrackForRollback, rollbackManager.getAlreadyBrokenServices());
+            // Convert broken services names from String to GreengrassService type
+            Set<GreengrassService> brokenServices = servicesToTrackForRollback.stream()
+                    .filter(service -> rollbackManager.getAlreadyBrokenServices().contains(service.getName()))
+                    .collect(Collectors.toSet());
 
+            // Also don't track services if they have (transitive) hard dependencies on already-broken services
+            Set<GreengrassService> brokenServiceAndDependers = kernel.findDependers(brokenServices);
             servicesToTrackForRollback.removeAll(brokenServiceAndDependers);
 
             logger.atInfo(MERGE_CONFIG_EVENT_KEY)
@@ -170,37 +173,6 @@ void rollback(DeploymentDocument deploymentDocument, CompletableFuture<Deploymen
         }
     }
 
-    /**
-     * Finds all services which are dependers of given broken services, directly or indirectly
-     * This method performs a breadth-first search, starting from the broken services and traversing through
-     * service dependencies.
-     * @param rollbackServices the set of rollback services to track
-     * @param brokenServiceNames the set of broken service names
-     * @return a set of all services depending on the broken services, including themselves
-     */
-    @SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE")
-    private Set<GreengrassService> findServiceDependers(final Set<GreengrassService> rollbackServices,
-                                                        final Set<String> brokenServiceNames) {
-
-        Set<GreengrassService> dependerServices = rollbackServices.stream()
-                .filter(service -> brokenServiceNames.contains(service.getName()))
-                .collect(Collectors.toSet());
-        Queue<GreengrassService> dependers = new LinkedList<>(dependerServices);
-
-        // Breadth-first search to find all dependent services, staring from broken services
-        while (!dependers.isEmpty()) {
-            GreengrassService currentService = dependers.poll();
-            for (GreengrassService depender : currentService.getHardDependers()) {
-                // Ensure dependers haven't been processed
-                if (dependerServices.add(depender)) {
-                    dependers.offer(depender);
-                }
-            }
-        }
-        return dependerServices;
-    }
-
-
     private void handleFailureRollback(CompletableFuture totallyCompleteFuture, Throwable deploymentFailureCause,
                                        Throwable rollbackFailureCause) {
         // Rollback execution failed
@@ -209,5 +181,4 @@ private void handleFailureRollback(CompletableFuture totallyCompleteFuture, Thro
         totallyCompleteFuture.complete(new DeploymentResult(DeploymentResult.DeploymentStatus.FAILED_UNABLE_TO_ROLLBACK,
                 deploymentFailureCause));
     }
-
 }

src/main/java/com/aws/greengrass/lifecyclemanager/Kernel.java

@@ -80,10 +80,13 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Queue;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
@@ -913,4 +916,49 @@ private void setupProxy() {
     public List<String> getSupportedCapabilities() {
         return SUPPORTED_CAPABILITIES;
     }
+
+    /**
+     * Finds all auto startable services with auto startable dependencies.
+     * This method performs a breadth-first search, starting from the target services and traversing through
+     * all hard dependencies and exclude non auto startable services from.
+     *
+     * @return a set of all services that only contains auto startable services and their dependencies are all
+     *      auto startable services
+     */
+    public Set<GreengrassService> findAutoStartableServicesToTrack() {
+        // Find all non auto startable services
+        Set<GreengrassService> nonAutoStartableServices = orderedDependencies().stream()
+                .filter(service -> !service.shouldAutoStart()).collect(Collectors.toSet());
+
+        Set<GreengrassService> nonAutoStartableDependers = findDependers(nonAutoStartableServices);
+
+        // Return the set which excludes all non auto startable services and their dependers
+        return orderedDependencies().stream()
+                .filter(service -> !nonAutoStartableDependers.contains(service))
+                .collect(Collectors.toSet());
+    }
+
+    /**
+     * Finds all services which are dependers of initial services, directly or indirectly
+     * This method performs a breadth-first search, starting from the initial services and traversing through
+     * all hard dependencies.
+     * @param initialServices the set of services that we want to find dependers
+     * @return a set of all services that depend on the target services, including the initial services
+     */
+    @SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE")
+    public Set<GreengrassService> findDependers(Set<GreengrassService> initialServices) {
+        Queue<GreengrassService> dependers = new LinkedList<>(initialServices);
+
+        // Breadth-first search to find all dependent services, staring from non auto startable services
+        while (!dependers.isEmpty()) {
+            GreengrassService currentService = dependers.poll();
+            for (GreengrassService depender : currentService.getHardDependers()) {
+                // Ensure dependers haven't been processed
+                if (initialServices.add(depender)) {
+                    dependers.offer(depender);
+                }
+            }
+        }
+        return initialServices;
+    }
 }

src/main/java/com/aws/greengrass/lifecyclemanager/KernelLifecycle.java

@@ -600,19 +600,19 @@ GreengrassService getMain() {
      * @return true if all services in terminal states
      */
     public boolean allServicesInTerminalState() {
-        List<GreengrassService> servicesToTrack = kernel.orderedDependencies().stream()
-                .filter(GreengrassService::shouldAutoStart).collect(Collectors.toList());
+        List<GreengrassService> servicesToTrack = kernel.findAutoStartableServicesToTrack()
+                .stream().collect(Collectors.toList());
         return servicesToTrack.stream().allMatch(service -> {
-                    State state = service.getState();
-                    // service is broken
-                    if (State.BROKEN.equals(state)) {
-                        return true;
-                    }
-                    // or service has reached desired state, and it is either running or finished
-                    if (service.reachedDesiredState()) {
-                        return State.RUNNING.equals(state) || State.FINISHED.equals(state);
-                    }
-                    return false;
-                });
+            State state = service.getState();
+            // service is broken
+            if (State.BROKEN.equals(state)) {
+                return true;
+            }
+            // or service has reached desired state, and it is either running or finished
+            if (service.reachedDesiredState()) {
+                return State.RUNNING.equals(state) || State.FINISHED.equals(state);
+            }
+            return false;
+        });
     }
 }

src/main/java/com/aws/greengrass/util/DependerFinder.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package com.aws.greengrass.util;
+
+import com.aws.greengrass.lifecyclemanager.GreengrassService;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
+
+public final class DependerFinder {
+    private DependerFinder() {
+    }
+
+    /**
+     * Finds all services which are dependers of target services, directly or indirectly
+     * This method performs a breadth-first search, starting from the target services and traversing through
+     * all hard dependencies.
+     * @param targetServices the set of services that we want to find their dependers
+     * @return a set of all services that depend on the target services, including the target services
+     */
+    @SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE")
+    public static Set<GreengrassService> findTargetServicesDependers(final Set<GreengrassService> targetServices) {
+        Queue<GreengrassService> dependers = new LinkedList<>(targetServices);
+
+        // Breadth-first search to find all dependent services, staring from broken services
+        while (!dependers.isEmpty()) {
+            GreengrassService currentService = dependers.poll();
+            for (GreengrassService depender : currentService.getHardDependers()) {
+                // Ensure dependers haven't been processed
+                if (targetServices.add(depender)) {
+                    dependers.offer(depender);
+                }
+            }
+        }
+        return targetServices;
+    }
+
+}