feat(systemd): Add WasSkippedDueToConditions method and handle skipped services

Implement the WasSkippedDueToConditions  method in the systemd Commander to check
if service conditions are met. Update the WaitForServiceSuccessfullyFinished
function to handle cases where services are skipped due to unmet conditions,
indicating that their work was already completed in a previous run. This
enhancement improves service management and logging clarity.

Author: praveenkumar

pkg/crc/cluster/cluster.go

@@ -187,6 +187,8 @@ func EnsureSSHKeyPresentInTheCluster(ctx context.Context, ocConfig oc.Config, ss
 // 1. Run (verified by checking ExecMainExitTimestamp changes)
 // 2. Finish (transition to Stopped state)
 // 3. Exit with Result=success
+// It also handles services that are skipped due to unmet conditions (e.g., ConditionPathExists).
+// When a service is skipped, its work was already done in a previous run.
 func WaitForServiceSuccessfullyFinished(ctx context.Context, systemdRunner *systemd.Commander,
 	serviceName string, timeout, retryInterval time.Duration) error {
 	return errors.Retry(ctx, timeout, func() error {
@@ -208,6 +210,21 @@ func WaitForServiceSuccessfullyFinished(ctx context.Context, systemdRunner *syst
 		logging.Debugf("Service %s current ExecMainExitTimestamp: '%s'", serviceName, currentExecMainExitTimestamp)
 
 		if currentExecMainExitTimestamp == "" {
+			// No exit timestamp means service didn't run. Check if it was skipped due to conditions.
+			// This can happen after system restart when ConditionPathExists marks work as already done.
+			wasSkipped, err := systemdRunner.WasSkippedDueToConditions(serviceName)
+			if err != nil {
+				return &errors.RetriableError{Err: err}
+			}
+			logging.Debugf("Service %s was skipped due to conditions: %v", serviceName, wasSkipped)
+
+			if wasSkipped {
+				// Service was skipped because conditions weren't met (e.g., .done file exists).
+				// This means the work was already completed in a previous run.
+				logging.Debugf("Service %s was skipped due to unmet conditions (work already done)", serviceName)
+				return nil
+			}
+
 			return &errors.RetriableError{Err: fmt.Errorf("service %s has not run yet (no exit timestamp)", serviceName)}
 		}
 

pkg/crc/systemd/systemd.go

@@ -81,6 +81,32 @@ func (c Commander) ExecMainExitTimestamp(name string) (string, error) {
 	return strings.TrimSpace(stdOut), nil
 }
 
+// WasSkippedDueToConditions returns true if the service was triggered but skipped
+// because its condition checks (e.g., ConditionPathExists) were not met.
+// This is determined by checking both ConditionResult and ConditionTimestamp:
+// - If ConditionTimestamp is empty, conditions were never evaluated (service never triggered)
+// - If ConditionTimestamp has a value and ConditionResult is "no", service was skipped
+func (c Commander) WasSkippedDueToConditions(name string) (bool, error) {
+	stdOut, stdErr, err := c.commandRunner.Run("systemctl", "show", "-p", "ConditionResult", "-p", "ConditionTimestamp", name)
+	if err != nil {
+		return false, fmt.Errorf("failed to get service condition info: %s %v: %s", stdOut, err, stdErr)
+	}
+
+	output := strings.TrimSpace(stdOut)
+	var conditionResult, conditionTimestamp string
+	for _, line := range strings.Split(output, "\n") {
+		if strings.HasPrefix(line, "ConditionResult=") {
+			conditionResult = strings.TrimPrefix(line, "ConditionResult=")
+		} else if strings.HasPrefix(line, "ConditionTimestamp=") {
+			conditionTimestamp = strings.TrimPrefix(line, "ConditionTimestamp=")
+		}
+	}
+
+	// Service was skipped only if conditions were actually evaluated (timestamp exists)
+	// AND the result was "no" (conditions not met)
+	return conditionTimestamp != "" && conditionResult == "no", nil
+}
+
 func (c Commander) DaemonReload() error {
 	stdOut, stdErr, err := c.commandRunner.RunPrivileged("Executing systemctl daemon-reload command", "systemctl", "daemon-reload")
 	if err != nil {