Handle uninstantiated template quadlets

Fixes: #26960

Signed-off-by: Šimon Brauner <sbrauner@redhat.com>

Author: simonbrauner

docs/source/markdown/podman-quadlet-list.1.md.in

@@ -23,8 +23,8 @@ Supported filters:
 | Filter     | Description                                                                                      |
 |------------|--------------------------------------------------------------------------------------------------|
 | name       | Filter by quadlet name                                                                           |
-| status     | Filter by quadlet status. Valid values: `Not loaded`, `active/running`, `inactive/dead`, `failed/failed`, `activating/start`, `deactivating/stop` |
 | pod        | Filter by the `Pod=` value (displays only for .container units)                                  |
+| status     | Filter by quadlet status. Valid values: `Not loaded`, `loaded template`, `active/running`, `inactive/dead`, `failed/failed`, `activating/start`, `deactivating/stop` |
 
 #### **--format**=*format*
 
@@ -38,7 +38,7 @@ Print results with a Go template.
 | .Name           | Name of the Quadlet file                         |
 | .Path           | Quadlet file path on disk                        |
 | .Pod            | Pod quadlet file from `Pod=` in `[Container]` (empty if not set) |
-| .Status         | Quadlet status corresponding to systemd unit     |
+| .Status         | Quadlet status corresponding to systemd unit (`Not loaded` and `loaded template` are from podman, other values are from systemd)    |
 | .UnitName       | Systemd unit name corresponding to quadlet       |
 
 @@option noheading

docs/source/markdown/podman-quadlet-rm.1.md

@@ -11,6 +11,8 @@ podman\-quadlet\-rm - Removes an installed quadlet
 Remove one or more installed Quadlets from the current user. Following command also takes application name
 as input and removes all the Quadlets which belongs to that specific application.
 
+When the argument is uninstantiated template quadlet, this command removes the template quadlet file (e.g. `templateName@.container`) and the generated systemd template unit (e.g. `templateName@.service`, unless **--reload-systemd** is set to `false`). Instances of the systemd template unit (e.g. `templateName@instanceName.service`) may persist, and can be removed with **systemctl(1)**.
+
 Note: If a quadlet is part of an application, removing that specific quadlet will remove the entire application.
 When a quadlet is installed from a directory, all files installed from that directory—including both quadlet and non-quadlet files—are considered part
 of a single application.
@@ -31,7 +33,8 @@ Do not error for Quadlets that do not exist.
 
 #### **--reload-systemd**
 
-Reload systemd after removing Quadlets (default true).
+Reload systemd after removing Quadlets if at least
+one of them had a corresponding systemd unit (default true).
 In order to disable it users need to manually set the value
 of this flag to `false`.
 

pkg/domain/infra/abi/quadlet.go

@@ -703,7 +703,8 @@ func (ic *ContainerEngine) QuadletList(ctx context.Context, options entities.Qua
 	}
 
 	reports := make([]*entities.ListQuadlet, 0, len(quadletPaths))
-	allServiceNames := make([]string, 0, len(quadletPaths))
+	concreteServiceNames := make([]string, 0, len(quadletPaths))
+	templateServiceNames := make([]string, 0, len(quadletPaths))
 	partialReports := make(map[string]entities.ListQuadlet)
 
 	for _, path := range quadletPaths {
@@ -728,16 +729,21 @@ func (ic *ContainerEngine) QuadletList(ctx context.Context, options entities.Qua
 			report.Pod = pod
 		}
 		partialReports[serviceName] = report
-		allServiceNames = append(allServiceNames, serviceName)
+
+		if systemdquadlet.IsTemplateUnitFileName(serviceName) {
+			templateServiceNames = append(templateServiceNames, serviceName)
+		} else {
+			concreteServiceNames = append(concreteServiceNames, serviceName)
+		}
 	}
 
-	// Get status of all systemd units with given names.
-	statuses, err := conn.ListUnitsByNamesContext(ctx, allServiceNames)
+	// Get status of concrete systemd units with given names.
+	statuses, err := conn.ListUnitsByNamesContext(ctx, concreteServiceNames)
 	if err != nil {
 		return nil, fmt.Errorf("querying systemd for unit status: %w", err)
 	}
-	if len(statuses) != len(allServiceNames) {
-		logrus.Warnf("Queried for %d services but received %d responses", len(allServiceNames), len(statuses))
+	if len(statuses) != len(concreteServiceNames) {
+		logrus.Warnf("Queried for %d services but received %d responses", len(concreteServiceNames), len(statuses))
 	}
 	for _, unitStatus := range statuses {
 		report, ok := partialReports[unitStatus.Name]
@@ -758,6 +764,30 @@ func (ic *ContainerEngine) QuadletList(ctx context.Context, options entities.Qua
 		delete(partialReports, unitStatus.Name)
 	}
 
+	// Uninstantiated template units need to be handled separately.
+	unitFiles, err := conn.ListUnitFilesByPatternsContext(ctx, []string{}, templateServiceNames)
+	if err != nil {
+		return nil, fmt.Errorf("querying systemd for unit file: %w", err)
+	}
+	unitFilesFound := make(map[string]struct{})
+	for _, unitFile := range unitFiles {
+		unitFilesFound[filepath.Base(unitFile.Path)] = struct{}{}
+	}
+	for _, templateServiceName := range templateServiceNames {
+		report := partialReports[templateServiceName]
+
+		report.UnitName = templateServiceName
+
+		if _, ok := unitFilesFound[templateServiceName]; ok {
+			report.Status = "loaded template"
+		} else {
+			report.Status = "Not loaded"
+		}
+
+		reports = append(reports, &report)
+		delete(partialReports, templateServiceName)
+	}
+
 	// This should not happen.
 	// Systemd will give us output for everything we sent to them, even if it's not a valid unit.
 	// We can find them with LoadState, as we do above.
@@ -869,10 +899,11 @@ func (ic *ContainerEngine) QuadletRemove(ctx context.Context, quadlets []string,
 	}
 	quadlets = expandQuadletList
 	allQuadletPaths := make([]string, 0, len(quadlets))
-	allServiceNames := make([]string, 0, len(quadlets))
+	concreteServiceNames := make([]string, 0, len(quadlets))
+	templateServiceNames := make([]string, 0, len(quadlets))
 	runningQuadlets := make([]string, 0, len(quadlets))
 	serviceNameToQuadletName := make(map[string]string)
-	needReload := options.ReloadSystemd
+	needReload := false
 
 	if len(quadlets) == 0 && !options.All {
 		return nil, errors.New("must provide at least 1 quadlet to remove")
@@ -949,15 +980,19 @@ func (ic *ContainerEngine) QuadletRemove(ctx context.Context, quadlets []string,
 			continue
 		}
 
-		allServiceNames = append(allServiceNames, serviceName)
+		if systemdquadlet.IsTemplateUnitFileName(serviceName) {
+			templateServiceNames = append(templateServiceNames, serviceName)
+		} else {
+			concreteServiceNames = append(concreteServiceNames, serviceName)
+		}
 		serviceNameToQuadletName[serviceName] = quadlet
 	}
 
-	if len(allServiceNames) != 0 {
+	if len(concreteServiceNames) != 0 {
 		// Check if units are loaded into systemd, and further if they are running.
 		// If running and force is not set, error.
 		// If force is set, try and stop the unit.
-		statuses, err := conn.ListUnitsByNamesContext(ctx, allServiceNames)
+		statuses, err := conn.ListUnitsByNamesContext(ctx, concreteServiceNames)
 		if err != nil {
 			return nil, fmt.Errorf("querying systemd for unit status: %w", err)
 		}
@@ -968,7 +1003,7 @@ func (ic *ContainerEngine) QuadletRemove(ctx context.Context, quadlets []string,
 				// Nothing to do here if it doesn't exist in systemd
 				continue
 			}
-			needReload = options.ReloadSystemd
+			needReload = needReload || options.ReloadSystemd
 			if unitStatus.ActiveState == "active" {
 				if !options.Force {
 					report.Errors[quadletName] = fmt.Errorf("quadlet %s is running and force is not set, refusing to remove: %w", quadletName, define.ErrQuadletRunning)
@@ -993,6 +1028,17 @@ func (ic *ContainerEngine) QuadletRemove(ctx context.Context, quadlets []string,
 		}
 	}
 
+	if len(templateServiceNames) != 0 {
+		// Uninstantiated template units need to be handled separately.
+		unitFiles, err := conn.ListUnitFilesByPatternsContext(ctx, []string{}, templateServiceNames)
+		if err != nil {
+			return nil, fmt.Errorf("querying systemd for unit file: %w", err)
+		}
+		if len(unitFiles) != 0 {
+			needReload = needReload || options.ReloadSystemd
+		}
+	}
+
 	// Remove the actual files behind the quadlets
 	if len(allQuadletPaths) != 0 {
 		for _, path := range allQuadletPaths {

pkg/systemd/quadlet/quadlet.go

@@ -939,8 +939,9 @@ func ConvertContainer(container *parser.UnitFile, unitsInfoMap map[string]*UnitI
 	return service, warnings, nil
 }
 
-func isTemplateUnit(unit *parser.UnitFile) bool {
-	base := strings.TrimSuffix(unit.Filename, filepath.Ext(unit.Filename))
+// Determine if the given file name belongs to an uninstantiated template unit.
+func IsTemplateUnitFileName(fileName string) bool {
+	base := strings.TrimSuffix(fileName, filepath.Ext(fileName))
 	return strings.HasSuffix(base, "@")
 }
 
@@ -2227,7 +2228,7 @@ func handlePod(quadletUnitFile, serviceUnitFile *parser.UnitFile, groupName stri
 		// If we want to start the container with the pod, we add it to this list.
 		// This creates corresponding Wants=/Before= statements in the pod service.
 		// Do not add this for template units as dependency cannot be created for them.
-		if !isTemplateUnit(quadletUnitFile) && quadletUnitFile.LookupBooleanWithDefault(groupName, KeyStartWithPod, true) {
+		if !IsTemplateUnitFileName(quadletUnitFile.Filename) && quadletUnitFile.LookupBooleanWithDefault(groupName, KeyStartWithPod, true) {
 			podInfo.ContainersToStart = append(podInfo.ContainersToStart, serviceUnitFile.Filename)
 		}
 	}

test/system/253-podman-quadlet.bats

@@ -154,6 +154,44 @@ EOF
     run_podman quadlet rm $ctr_unit
 }
 
+@test "quadlet verb - install, list, print, rm - template" {
+    # Determine the install directory path based on rootless/root
+    local install_dir
+    install_dir=$(get_quadlet_install_dir)
+    # Create a test quadlet file
+    local quadlet_name=templated-quadlet@.container
+    local quadlet_unit_name=${quadlet_name%.container}.service
+    local quadlet_file=$PODMAN_TMPDIR/$quadlet_name
+    cat > "$quadlet_file" <<EOF
+[Container]
+Image=$IMAGE
+Exec=sh -c "echo STARTED CONTAINER; trap 'exit' SIGTERM; while :; do sleep 0.1; done"
+EOF
+    # Test quadlet install
+    run_podman quadlet install "$quadlet_file"
+    # Verify install output contains the quadlet name
+    assert "$output" =~ "$quadlet_name" "install output should contain quadlet name"
+
+    # Test quadlet list
+    run_podman quadlet list
+    assert "$output" =~ "$quadlet_name" "list should contain $quadlet_name"
+    assert "$output" =~ "$quadlet_unit_name" "UNIT NAME should be $quadlet_unit_name"
+    # Loaded status should be loaded template
+    assert "$output" =~ "loaded template" "STATUS should be 'loaded template'"
+    assert "$output" =~ "$install_dir/$quadlet_name" "PATH ON DISK should show the quadlet file path"
+
+    # Test quadlet print
+    run_podman quadlet print "$quadlet_name"
+    assert "$output" == "$(<"$quadlet_file")" "print output matches quadlet file"
+
+    # Test quadlet rm
+    run_podman quadlet rm "$quadlet_name"
+    # Verify remove output contains the quadlet name
+    assert "$output" =~ "$quadlet_name" "remove output should contain quadlet name"
+    # Verify removal
+    run_podman quadlet list
+    assert "$output" !~ "$quadlet_name" "list should not contain removed container"
+}
 
 @test "quadlet verb - install multiple files from directory and remove by app name" {
     # Create a directory for multiple quadlet files