#1570. Connect Action

.github/workflows/test-ui.yml

@@ -53,7 +53,8 @@ jobs:
           export NODE_PATH=$(pwd)/src/ui/node_modules &&
           npm --prefix src/ui run test:pre-init &&
           npm --prefix src/ui run test:init &&
-          npm --prefix src/ui run test:post-init
+          npm --prefix src/ui run test:post-init &&
+          npm --prefix src/ui run test:connect
 
       - name: Save logs
         if: always()

src/internal/api/packages/tunnels.go

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021-Present The Zarf Authors
+
+// Package packages provides api functions for managing Zarf packages.
+package packages
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/defenseunicorns/zarf/src/internal/api/common"
+	"github.com/defenseunicorns/zarf/src/internal/cluster"
+	"github.com/defenseunicorns/zarf/src/pkg/message"
+	"github.com/defenseunicorns/zarf/src/types"
+	"github.com/go-chi/chi/v5"
+)
+
+// PackageTunnel is a struct for storing a tunnel and its connection details
+type PackageTunnel struct {
+	tunnel     *cluster.Tunnel
+	Connection types.APIDeployedPackageConnection `json:"connection,omitempty"`
+}
+
+// packageTunnels is a map of package names to PackageTunnel objects
+type packageTunnels map[string]map[string]PackageTunnel
+
+// tunnels is a map of package names to tunnel objects used for storing connected tunnels
+var tunnels = make(packageTunnels)
+
+// ListConnections returns a map of pkgName to a list of connections
+func ListConnections(w http.ResponseWriter, _ *http.Request) {
+	allConnections := make(types.APIConnections)
+	for name, pkgTunnels := range tunnels {
+		for _, pkgTunnel := range pkgTunnels {
+			if allConnections[name] == nil {
+				allConnections[name] = make(types.APIDeployedPackageConnections, 0)
+			}
+			allConnections[name] = append(allConnections[name], pkgTunnel.Connection)
+		}
+	}
+	common.WriteJSONResponse(w, allConnections, http.StatusOK)
+}
+
+// ListPackageConnections lists all tunnel names
+func ListPackageConnections(w http.ResponseWriter, r *http.Request) {
+	pkgName := chi.URLParam(r, "pkg")
+	if tunnels[pkgName] == nil {
+		message.ErrorWebf(errors.New("No tunnels for package %s"), w, pkgName)
+		return
+	}
+	pkgTunnels := make(types.APIDeployedPackageConnections, 0, len(tunnels[pkgName]))
+	for _, pkgTunnel := range tunnels[pkgName] {
+		pkgTunnels = append(pkgTunnels, pkgTunnel.Connection)
+	}
+
+	common.WriteJSONResponse(w, pkgTunnels, http.StatusOK)
+}
+
+// ConnectTunnel establishes a tunnel for the requested resource
+func ConnectTunnel(w http.ResponseWriter, r *http.Request) {
+	pkgName := chi.URLParam(r, "pkg")
+	connectionName := chi.URLParam(r, "name")
+
+	if tunnels[pkgName] == nil {
+		tunnels[pkgName] = make(map[string]PackageTunnel)
+	}
+
+	pkgTunnels := tunnels[pkgName]
+
+	if pkgTunnels[connectionName].tunnel != nil {
+		common.WriteJSONResponse(w, tunnels[pkgName][connectionName].Connection, http.StatusOK)
+		return
+	}
+
+	tunnel, err := cluster.NewZarfTunnel()
+
+	if err != nil {
+		message.ErrorWebf(err, w, "Failed to create tunnel for %s", connectionName)
+		return
+	}
+
+	err = tunnel.Connect(connectionName, false)
+	if err != nil {
+		message.ErrorWebf(err, w, "Failed to connect to %s", connectionName)
+		return
+	}
+
+	tunnels[pkgName][connectionName] = PackageTunnel{
+		tunnel: tunnel,
+		Connection: types.APIDeployedPackageConnection{
+			Name: connectionName,
+			URL:  tunnel.FullURL(),
+		},
+	}
+	common.WriteJSONResponse(w, tunnels[pkgName][connectionName].Connection, http.StatusCreated)
+}
+
+// DisconnectTunnel closes the tunnel for the requested resource
+func DisconnectTunnel(w http.ResponseWriter, r *http.Request) {
+	pkgName := chi.URLParam(r, "pkg")
+	connectionName := chi.URLParam(r, "name")
+	pkgTunnel := tunnels[pkgName][connectionName]
+	if pkgTunnel.tunnel == nil {
+		message.ErrorWebf(errors.New("Tunnel not found"), w, "Failed to disconnect from %s", connectionName)
+		return
+	}
+
+	pkgTunnel.tunnel.Close()
+	delete(tunnels[pkgName], connectionName)
+
+	common.WriteJSONResponse(w, true, http.StatusOK)
+}

src/internal/api/start.go

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2021-Present The Zarf Authors
 
 // Package api provides the UI API server.
@@ -93,12 +94,15 @@ func LaunchAPIServer() {
 			r.Put("/deploy", packages.DeployPackage)
 			r.Get("/deploy-stream", packages.StreamDeployPackage)
 			r.Delete("/remove/{name}", packages.RemovePackage)
+			r.Put("/{pkg}/connect/{name}", packages.ConnectTunnel)
+			r.Delete("/{pkg}/disconnect/{name}", packages.DisconnectTunnel)
+			r.Get("/{pkg}/connections", packages.ListPackageConnections)
+			r.Get("/connections", packages.ListConnections)
 		})
 
 		r.Route("/components", func(r chi.Router) {
 			r.Get("/deployed", components.ListDeployingComponents)
 		})
-
 	})
 
 	// If no dev port specified, use the server port for the URL and try to open it

src/internal/cluster/tunnel.go

@@ -318,6 +318,11 @@ func (tunnel *Tunnel) HTTPEndpoint() string {
 	return fmt.Sprintf("http://%s", tunnel.Endpoint())
 }
 
+// FullURL returns the tunnel endpoint as a HTTP URL string with the urlSuffix appended.
+func (tunnel *Tunnel) FullURL() string {
+	return fmt.Sprintf("%s%s", tunnel.HTTPEndpoint(), tunnel.urlSuffix)
+}
+
 // Close disconnects a tunnel connection by closing the StopChan, thereby stopping the goroutine.
 func (tunnel *Tunnel) Close() {
 	message.Debug("tunnel.Close()")

src/internal/cluster/zarf.go

@@ -97,7 +97,7 @@ func (c *Cluster) StripZarfLabelsAndSecretsFromNamespaces() {
 }
 
 // RecordPackageDeployment saves metadata about a package that has been deployed to the cluster.
-func (c *Cluster) RecordPackageDeployment(pkg types.ZarfPackage, components []types.DeployedComponent) {
+func (c *Cluster) RecordPackageDeployment(pkg types.ZarfPackage, components []types.DeployedComponent, connectStrings types.ConnectStrings) {
 	// Generate a secret that describes the package that is being deployed
 	packageName := pkg.Metadata.Name
 	deployedPackageSecret := c.Kube.GenerateSecret(ZarfNamespaceName, config.ZarfPackagePrefix+packageName, corev1.SecretTypeOpaque)
@@ -108,6 +108,7 @@ func (c *Cluster) RecordPackageDeployment(pkg types.ZarfPackage, components []ty
 		CLIVersion:         config.CLIVersion,
 		Data:               pkg,
 		DeployedComponents: components,
+		ConnectStrings:     connectStrings,
 	})
 
 	deployedPackageSecret.Data = map[string][]byte{"data": stateData}

src/pkg/packager/deploy.go

@@ -78,12 +78,13 @@ func (p *Packager) Deploy() error {
 
 	// Notify all the things about the successful deployment
 	message.Successf("Zarf deployment complete")
+
 	p.printTablesForDeployment(deployedComponents)
 
 	// Save deployed package information to k8s
 	// Note: Not all packages need k8s; check if k8s is being used before saving the secret
 	if p.cluster != nil {
-		p.cluster.RecordPackageDeployment(p.cfg.Pkg, deployedComponents)
+		p.cluster.RecordPackageDeployment(p.cfg.Pkg, deployedComponents, connectStrings)
 	}
 
 	return nil

src/test/ui/04_connect_doom.spec.ts

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021-Present The Zarf Authors
+
+import { expect, test } from '@playwright/test';
+
+test.describe.serial('connect the dos-games package @connect', async () => {
+	test.beforeEach(async ({ page }) => {
+		page.on('pageerror', (err) => console.log(err.message));
+		await page.goto('/auth?token=insecure', { waitUntil: 'networkidle' });
+	});
+
+	test('connect the dos-games package', async ({ page }) => {
+		let menu = await openDosGamesMenu(page);
+
+		// Ensure the menu contains the Connect option
+		expect(await menu.textContent()).toContain('Connect...');
+
+		const connect = menu.locator('span:text-is("Connect...")').first();
+
+		// Open Connect Deployed Package Dialog
+		await connect.click();
+
+		const connectDialog = page.locator('.dialog-open');
+		expect(await connectDialog.textContent()).toContain('Connect to Resource');
+		const connectButton = connectDialog.locator('button:has-text("Connect")');
+
+		// Click the Connect Button
+		await Promise.all([
+			page.waitForResponse('api/packages/dos-games/connect/doom'),
+			connectButton.click(),
+		]);
+
+		menu = await openDosGamesMenu(page);
+		expect(await menu.textContent()).toContain('Disconnect...');
+	});
+
+	test('disconnect the dos-games package', async ({ page }) => {
+		// Dispose context once it's no longer needed.
+		let menu = await openDosGamesMenu(page);
+
+		// Ensure the menu contains the Disconnect option
+		expect(await menu.textContent()).toContain('Disconnect...');
+
+		const disconnect = menu.locator('span:text-is("Disconnect...")');
+
+		// Open Disconnect Deployed Package Dialog
+		await disconnect.click();
+
+		const dialog = page.locator('.dialog-open');
+		expect(await dialog.textContent()).toContain('Disconnect Resource');
+		const disconnectButton = dialog.locator('.button-label:text-is("Disconnect")');
+
+		// Click the Disconnect Button
+		await Promise.all([
+			page.waitForResponse('api/packages/dos-games/disconnect/doom'),
+			disconnectButton.click(),
+		]);
+
+		// Ensure the menu no longer contains the Disconnect option
+		menu = await openDosGamesMenu(page);
+		expect(await menu.textContent()).not.toContain('Disconnect...');
+	});
+});
+
+async function openDosGamesMenu(page: any) {
+	// Find Dos Games Package in Packages Table
+	const packageTableBody = page.locator('.package-list-body');
+	const packageRow = packageTableBody.locator('.package-table-row:has-text("dos-games")');
+
+	// Open the menu for the package
+	const more = packageRow.locator('.more > button').first();
+	await more.click();
+
+	// Find the menu and return it
+	const menu = page.locator('.menu.open');
+	return menu;
+}

src/types/api.go

@@ -4,21 +4,26 @@
 // Package types contains all the types used by Zarf.
 package types
 
-import "k8s.io/client-go/tools/clientcmd/api"
+import (
+	"k8s.io/client-go/tools/clientcmd/api"
+)
 
 // RestAPI is the struct that is used to marshal/unmarshal the top-level API objects.
 type RestAPI struct {
-	ZarfPackage          ZarfPackage          `json:"zarfPackage"`
-	ZarfState            ZarfState            `json:"zarfState"`
-	ZarfCommonOptions    ZarfCommonOptions    `json:"zarfCommonOptions"`
-	ZarfCreateOptions    ZarfCreateOptions    `json:"zarfCreateOptions"`
-	ZarfDeployOptions    ZarfDeployOptions    `json:"zarfDeployOptions"`
-	ZarfInitOptions      ZarfInitOptions      `json:"zarfInitOptions"`
-	ConnectStrings       ConnectStrings       `json:"connectStrings"`
-	ClusterSummary       ClusterSummary       `json:"clusterSummary"`
-	DeployedPackage      DeployedPackage      `json:"deployedPackage"`
-	APIZarfPackage       APIZarfPackage       `json:"apiZarfPackage"`
-	APIZarfDeployPayload APIZarfDeployPayload `json:"apiZarfDeployPayload"`
+	ZarfPackage                   ZarfPackage                   `json:"zarfPackage"`
+	ZarfState                     ZarfState                     `json:"zarfState"`
+	ZarfCommonOptions             ZarfCommonOptions             `json:"zarfCommonOptions"`
+	ZarfCreateOptions             ZarfCreateOptions             `json:"zarfCreateOptions"`
+	ZarfDeployOptions             ZarfDeployOptions             `json:"zarfDeployOptions"`
+	ZarfInitOptions               ZarfInitOptions               `json:"zarfInitOptions"`
+	ConnectStrings                ConnectStrings                `json:"connectStrings"`
+	ClusterSummary                ClusterSummary                `json:"clusterSummary"`
+	DeployedPackage               DeployedPackage               `json:"deployedPackage"`
+	APIZarfPackage                APIZarfPackage                `json:"apiZarfPackage"`
+	APIZarfDeployPayload          APIZarfDeployPayload          `json:"apiZarfDeployPayload"`
+	APIZarfPackageConnection      APIDeployedPackageConnection  `json:"apiZarfPackageConnection"`
+	APIDeployedPackageConnections APIDeployedPackageConnections `json:"apiZarfPackageConnections"`
+	APIConnections                APIConnections                `json:"apiConnections"`
 }
 
 // ClusterSummary contains the summary of a cluster for the API.
@@ -42,3 +47,15 @@ type APIZarfDeployPayload struct {
 	DeployOpts ZarfDeployOptions `json:"deployOpts"`
 	InitOpts   *ZarfInitOptions  `json:"initOpts,omitempty"`
 }
+
+// APIConnections represents all of the existing connections
+type APIConnections map[string]APIDeployedPackageConnections
+
+// APIDeployedPackageConnections represents all of the connections for a deployed package
+type APIDeployedPackageConnections []APIDeployedPackageConnection
+
+// APIDeployedPackageConnection represents a single connection from a deployed package
+type APIDeployedPackageConnection struct {
+	Name string `json:"name"`
+	URL  string `json:"url,omitempty"`
+}

src/types/k8s.go

@@ -28,6 +28,7 @@ type DeployedPackage struct {
 	CLIVersion string      `json:"cliVersion"`
 
 	DeployedComponents []DeployedComponent `json:"deployedComponents"`
+	ConnectStrings     ConnectStrings      `json:"connectStrings,omitempty"`
 }
 
 // DeployedComponent contains information about a Zarf Package Component that has been deployed to a cluster.