quadlet install: multiple quadlets from single file should share app

Quadlets installed from `.quadlet` file now belongs to a single
application, anyone file removed from this application removes all the
other files as well.

Assited by: claude-4-sonnet

Signed-off-by: flouthoc <flouthoc.git@gmail.com>

Author: flouthoc

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

@@ -16,9 +16,9 @@ This command allows you to:
 
     * Specify a directory containing multiple Quadlet files and other non-Quadlet files for installation ( example a config file for a quadlet container ).
 
-    * Install multiple Quadlets from a single file with `.quadlets` extension where each Quadlet is separated by a `---` delimiter. When using multiple quadlets in a single file, each quadlet section must include a `# FileName=<name>` comment to specify the name for that quadlet.
+    * Install multiple Quadlets from a single file with the `.quadlets` extension, where each Quadlet is separated by a `---` delimiter. When using multiple quadlets in a single `.quadlets` file, each quadlet section must include a `# FileName=<name>` comment to specify the name for that quadlet.
 
-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.
+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. Similarly, when multiple quadlets are installed from a single `.quadlets` file, they are all considered part of the same application.
 
 Note: In case user wants to install Quadlet application then first path should be the path to application directory.
 

pkg/domain/infra/abi/quadlet.go

@@ -164,7 +164,15 @@ func (ic *ContainerEngine) QuadletInstall(ctx context.Context, pathsOrURLs []str
 	for _, toInstall := range paths {
 		validateQuadletFile := false
 		if assetFile == "" {
-			assetFile = "." + filepath.Base(toInstall) + ".asset"
+			// Check if this is a .quadlets file - if so, treat as an app
+			ext := strings.ToLower(filepath.Ext(toInstall))
+			if ext == ".quadlets" {
+				// For .quadlets files, use .app extension to group all quadlets as one application
+				baseName := strings.TrimSuffix(filepath.Base(toInstall), filepath.Ext(toInstall))
+				assetFile = "." + baseName + ".app"
+			} else {
+				assetFile = "." + filepath.Base(toInstall) + ".asset"
+			}
 			validateQuadletFile = true
 		}
 		switch {
@@ -215,19 +223,6 @@ func (ic *ContainerEngine) QuadletInstall(ctx context.Context, pathsOrURLs []str
 			ext := strings.ToLower(filepath.Ext(toInstall))
 			isQuadletsFile := ext == ".quadlets"
 
-			// Only check for multi-quadlet content if it's a .quadlets file
-			var isMulti bool
-			if isQuadletsFile {
-				var err error
-				isMulti, err = isMultiQuadletFile(toInstall)
-				if err != nil {
-					installReport.QuadletErrors[toInstall] = fmt.Errorf("unable to check if file is multi-quadlet: %w", err)
-					continue
-				}
-				// For .quadlets files, always treat as multi-quadlet (even single quadlets)
-				isMulti = true
-			}
-
 			// Handle files with unsupported extensions that are not .quadlets files
 			if !hasValidExt && !isQuadletsFile {
 				// If we're installing as part of an app (assetFile is set), allow non-quadlet files as assets
@@ -241,7 +236,7 @@ func (ic *ContainerEngine) QuadletInstall(ctx context.Context, pathsOrURLs []str
 				}
 			}
 
-			if isMulti {
+			if isQuadletsFile {
 				// Parse the multi-quadlet file
 				quadlets, err := parseMultiQuadletFile(toInstall)
 				if err != nil {
@@ -385,6 +380,14 @@ func (ic *ContainerEngine) installQuadlet(_ context.Context, path, destName, ins
 		if err != nil {
 			return "", fmt.Errorf("error while writing non-quadlet filename: %w", err)
 		}
+	} else if strings.HasSuffix(assetFile, ".app") {
+		// For quadlet files that are part of an application (indicated by .app extension),
+		// also write the quadlet filename to the .app file for proper application tracking
+		quadletName := filepath.Base(finalPath)
+		err := appendStringToFile(filepath.Join(installDir, assetFile), quadletName)
+		if err != nil {
+			return "", fmt.Errorf("error while writing quadlet filename to app file: %w", err)
+		}
 	}
 	return finalPath, nil
 }
@@ -550,24 +553,6 @@ func detectQuadletType(content string) (string, error) {
 	return "", fmt.Errorf("no recognized quadlet section found (expected [Container], [Volume], [Network], [Kube], [Image], [Build], or [Pod])")
 }
 
-// isMultiQuadletFile checks if a file contains multiple quadlets by looking for "---" delimiter
-// The delimiter must be on its own line (possibly with whitespace)
-func isMultiQuadletFile(filePath string) (bool, error) {
-	content, err := os.ReadFile(filePath)
-	if err != nil {
-		return false, err
-	}
-
-	lines := strings.Split(string(content), "\n")
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "---" {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
 // buildAppMap scans the given directory for files that start with '.'
 // and end with '.app', reads their contents (one filename per line), and
 // returns a map where each filename maps to the .app file that contains it.

test/system/254-podman-quadlet-multi.bats

@@ -121,11 +121,8 @@ EOF
     # Verify the container quadlet was removed but others remain
     run_podman quadlet list
     assert "$output" !~ "webserver.container" "list should not contain removed webserver.container"
-    assert "$output" =~ "appstorage.volume" "list should still contain appstorage.volume"
-    assert "$output" =~ "appnetwork.network" "list should still contain appnetwork.network"
-
-    # Clean up remaining quadlets
-    run_podman quadlet rm appstorage.volume appnetwork.network
+    assert "$output" !~ "appstorage.volume" "list should not contain appstorage.volume as app is removed"
+    assert "$output" !~ "appnetwork.network" "list should not contain appnetwork.network as app is removed"
 }
 
 @test "quadlet verb - install multi-quadlet file with empty sections" {
@@ -180,3 +177,195 @@ EOF
     run_podman 125 quadlet install $multi_quadlet_file
     assert "$output" =~ "missing required.*FileName" "error should mention missing FileName"
 }
+
+@test "quadlet verb - multi-quadlet file creates application" {
+    # Test that quadlets from a .quadlets file are treated as part of the same application
+    local install_dir=$(get_quadlet_install_dir)
+    local multi_quadlet_file=$PODMAN_TMPDIR/myapp.quadlets
+
+    cat > $multi_quadlet_file <<EOF
+# FileName=webapp
+[Container]
+Image=$IMAGE
+ContainerName=webapp
+PublishPort=8080:80
+
+---
+
+# FileName=webdb
+[Volume]
+Label=app=myapp
+EOF
+
+    # Install the multi-quadlet file
+    run_podman quadlet install $multi_quadlet_file
+
+    # Verify both quadlets were installed
+    assert "$output" =~ "webapp.container" "install output should contain webapp.container"
+    assert "$output" =~ "webdb.volume" "install output should contain webdb.volume"
+
+    # Check that the .app file was created (not individual .asset files)
+    [[ -f "$install_dir/.myapp.app" ]] || die ".myapp.app file should exist"
+    [[ ! -f "$install_dir/.webapp.container.asset" ]] || die "individual .asset files should not exist"
+    [[ ! -f "$install_dir/.webdb.volume.asset" ]] || die "individual .asset files should not exist"
+
+    # Verify the .app file contains both quadlet names
+    run cat "$install_dir/.myapp.app"
+    assert "$output" =~ "webapp.container" ".app file should contain webapp.container"
+    assert "$output" =~ "webdb.volume" ".app file should contain webdb.volume"
+
+    # Test quadlet list to verify both quadlets show the same app name
+    run_podman quadlet list
+    local webapp_line=$(echo "$output" | grep "webapp.container")
+    local webdb_line=$(echo "$output" | grep "webdb.volume")
+
+    # Both lines should contain the same app name (.myapp.app)
+    assert "$webapp_line" =~ "\\.myapp\\.app" "webapp should show .myapp.app as app"
+    assert "$webdb_line" =~ "\\.myapp\\.app" "webdb should show .myapp.app as app"
+
+    # Test removing the application by removing one quadlet should remove both
+    run_podman quadlet rm webapp.container
+
+    # Both quadlets should be removed since they're part of the same app
+    run_podman quadlet list
+    assert "$output" !~ "webapp.container" "webapp.container should be removed"
+    assert "$output" !~ "webdb.volume" "webdb.volume should also be removed as part of same app"
+
+    # The .app file should also be removed
+    [[ ! -f "$install_dir/.myapp.app" ]] || die ".myapp.app file should be removed"
+}
+
+@test "quadlet verb - install directory with mixed individual and .quadlets files" {
+    # Test installing from a directory containing both individual quadlet files and .quadlets files
+    local install_dir=$(get_quadlet_install_dir)
+    local app_dir=$PODMAN_TMPDIR/mixed-app
+    mkdir -p "$app_dir"
+
+    # Create an individual container quadlet file
+    cat > "$app_dir/frontend.container" <<EOF
+[Container]
+Image=$IMAGE
+ContainerName=frontend-app
+PublishPort=3000:3000
+EOF
+
+    # Create an individual volume quadlet file
+    cat > "$app_dir/data.volume" <<EOF
+[Volume]
+Label=app=mixed-app
+Label=component=storage
+EOF
+
+    # Create a .quadlets file with multiple quadlets
+    cat > "$app_dir/backend.quadlets" <<EOF
+# FileName=api-server
+[Container]
+Image=$IMAGE
+ContainerName=api-server
+PublishPort=8080:8080
+
+---
+
+# FileName=cache
+[Volume]
+Label=app=mixed-app
+Label=component=cache
+
+---
+
+# FileName=app-network
+[Network]
+Subnet=192.168.1.0/24
+Gateway=192.168.1.1
+Label=app=mixed-app
+EOF
+
+    # Create a non-quadlet asset file (config file)
+    cat > "$app_dir/app.conf" <<EOF
+# Application configuration
+debug=true
+port=3000
+EOF
+
+    # Install the directory
+    run_podman quadlet install "$app_dir"
+
+    # Verify all quadlets were installed (2 individual + 3 from .quadlets file = 5 total)
+    assert "$output" =~ "frontend.container" "install output should contain frontend.container"
+    assert "$output" =~ "data.volume" "install output should contain data.volume"
+    assert "$output" =~ "api-server.container" "install output should contain api-server.container"
+    assert "$output" =~ "cache.volume" "install output should contain cache.volume"
+    assert "$output" =~ "app-network.network" "install output should contain app-network.network"
+
+    # Count lines in output (should be 6 lines: 5 quadlets + 1 asset file)
+    assert "${#lines[@]}" -eq 6 "install output should contain exactly six lines"
+
+    # Verify all files exist on disk
+    [[ -f "$install_dir/frontend.container" ]] || die "frontend.container should exist on disk"
+    [[ -f "$install_dir/data.volume" ]] || die "data.volume should exist on disk"
+    [[ -f "$install_dir/api-server.container" ]] || die "api-server.container should exist on disk"
+    [[ -f "$install_dir/cache.volume" ]] || die "cache.volume should exist on disk"
+    [[ -f "$install_dir/app-network.network" ]] || die "app-network.network should exist on disk"
+    [[ -f "$install_dir/app.conf" ]] || die "app.conf should exist on disk"
+
+    # Check that the .app file was created (all files are part of one application)
+    [[ -f "$install_dir/.mixed-app.app" ]] || die ".mixed-app.app file should exist"
+
+    # Verify the .app file contains all quadlet names
+    run cat "$install_dir/.mixed-app.app"
+    assert "$output" =~ "frontend.container" ".app file should contain frontend.container"
+    assert "$output" =~ "data.volume" ".app file should contain data.volume"
+    assert "$output" =~ "api-server.container" ".app file should contain api-server.container"
+    assert "$output" =~ "cache.volume" ".app file should contain cache.volume"
+    assert "$output" =~ "app-network.network" ".app file should contain app-network.network"
+
+    # Test quadlet list to verify all quadlets show the same app name
+    run_podman quadlet list
+    local frontend_line=$(echo "$output" | grep "frontend.container")
+    local data_line=$(echo "$output" | grep "data.volume")
+    local api_line=$(echo "$output" | grep "api-server.container")
+    local cache_line=$(echo "$output" | grep "cache.volume")
+    local network_line=$(echo "$output" | grep "app-network.network")
+
+    # All lines should contain the same app name (.mixed-app.app)
+    assert "$frontend_line" =~ "\\.mixed-app\\.app" "frontend should show .mixed-app.app as app"
+    assert "$data_line" =~ "\\.mixed-app\\.app" "data should show .mixed-app.app as app"
+    assert "$api_line" =~ "\\.mixed-app\\.app" "api-server should show .mixed-app.app as app"
+    assert "$cache_line" =~ "\\.mixed-app\\.app" "cache should show .mixed-app.app as app"
+    assert "$network_line" =~ "\\.mixed-app\\.app" "app-network should show .mixed-app.app as app"
+
+    # Verify content of individual quadlet files
+    run cat "$install_dir/frontend.container"
+    assert "$output" =~ "\\[Container\\]" "frontend container file should contain [Container] section"
+    assert "$output" =~ "ContainerName=frontend-app" "frontend container file should contain correct name"
+
+    run cat "$install_dir/api-server.container"
+    assert "$output" =~ "\\[Container\\]" "api-server container file should contain [Container] section"
+    assert "$output" =~ "ContainerName=api-server" "api-server container file should contain correct name"
+
+    run cat "$install_dir/app-network.network"
+    assert "$output" =~ "\\[Network\\]" "network file should contain [Network] section"
+    assert "$output" =~ "Subnet=192.168.1.0/24" "network file should contain correct subnet"
+
+    # Test that removing one quadlet removes the entire application
+    run_podman quadlet rm frontend.container
+
+    # All quadlets should be removed since they're part of the same app
+    run_podman quadlet list
+    assert "$output" !~ "frontend.container" "frontend.container should be removed"
+    assert "$output" !~ "data.volume" "data.volume should also be removed as part of same app"
+    assert "$output" !~ "api-server.container" "api-server.container should also be removed as part of same app"
+    assert "$output" !~ "cache.volume" "cache.volume should also be removed as part of same app"
+    assert "$output" !~ "app-network.network" "app-network.network should also be removed as part of same app"
+
+    # The .app file should also be removed
+    [[ ! -f "$install_dir/.mixed-app.app" ]] || die ".mixed-app.app file should be removed"
+
+    # All individual files should be removed
+    [[ ! -f "$install_dir/frontend.container" ]] || die "frontend.container should be removed"
+    [[ ! -f "$install_dir/data.volume" ]] || die "data.volume should be removed"
+    [[ ! -f "$install_dir/api-server.container" ]] || die "api-server.container should be removed"
+    [[ ! -f "$install_dir/cache.volume" ]] || die "cache.volume should be removed"
+    [[ ! -f "$install_dir/app-network.network" ]] || die "app-network.network should be removed"
+    [[ ! -f "$install_dir/app.conf" ]] || die "app.conf should be removed"
+}