@automattic/vip 4.1.5 → 4.1.8

package/internal/defensivemode/api.go

@@ -1,89 +0,0 @@
-// Package defensivemode is the M3+M4 test surface for the rechallenge
-// middleware. Two GraphQL mutations: UpdateDefensiveModeStatus and
-// UpdateDefensiveModeConfig. Both require step-up auth on production
-// environments — the rechallenge middleware in internal/gql handles that
-// transparently. M4: ports the raw HTTP POST to genqlient.
-package defensivemode
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/Khan/genqlient/graphql"
-
-	"github.com/Automattic/vip/internal/gql"
-)
-
-// UpdateStatusInput is the Go side of AppEnvironmentDefensiveModeUpdateStatusInput.
-// The Node wire format uses `id`/`environmentId`/`enabled` (NOT appId/envId);
-// genqlient handles the on-the-wire field names from the schema.
-type UpdateStatusInput struct {
-	AppID   int64
-	EnvID   int64
-	Enabled bool
-}
-
-type UpdateConfigInput struct {
-	AppID                         int64
-	EnvID                         int64
-	Enabled                       bool
-	ChallengeType                 int
-	ConnectionThresholdAbsolute   *int
-	ConnectionThresholdPercentage *int
-}
-
-type MutationResult struct {
-	Success bool
-	Message string
-}
-
-func UpdateDefensiveModeStatus(ctx context.Context, client graphql.Client, in UpdateStatusInput) (*MutationResult, error) {
-	input := &gql.AppEnvironmentDefensiveModeUpdateStatusInput{
-		Enabled:       in.Enabled,
-		EnvironmentId: in.EnvID,
-		Id:            in.AppID,
-	}
-	resp, err := gql.UpdateDefensiveModeStatus(ctx, client, input)
-	if err != nil {
-		return nil, err
-	}
-	if resp == nil || resp.UpdateDefensiveModeStatus == nil {
-		return nil, errMissingPayload("updateDefensiveModeStatus")
-	}
-	return &MutationResult{
-		Success: resp.UpdateDefensiveModeStatus.Success,
-		Message: resp.UpdateDefensiveModeStatus.Message,
-	}, nil
-}
-
-func UpdateDefensiveModeConfig(ctx context.Context, client graphql.Client, in UpdateConfigInput) (*MutationResult, error) {
-	input := &gql.AppEnvironmentDefensiveModeConfigInput{
-		Enabled:       in.Enabled,
-		EnvironmentId: in.EnvID,
-		Id:            in.AppID,
-		ChallengeType: int64(in.ChallengeType),
-	}
-	if in.ConnectionThresholdAbsolute != nil {
-		v := int64(*in.ConnectionThresholdAbsolute)
-		input.ConnectionThresholdAbsolute = &v
-	}
-	if in.ConnectionThresholdPercentage != nil {
-		v := int64(*in.ConnectionThresholdPercentage)
-		input.ConnectionThresholdPercentage = &v
-	}
-	resp, err := gql.UpdateDefensiveModeConfig(ctx, client, input)
-	if err != nil {
-		return nil, err
-	}
-	if resp == nil || resp.UpdateDefensiveModeConfig == nil {
-		return nil, errMissingPayload("updateDefensiveModeConfig")
-	}
-	return &MutationResult{
-		Success: resp.UpdateDefensiveModeConfig.Success,
-		Message: resp.UpdateDefensiveModeConfig.Message,
-	}, nil
-}
-
-func errMissingPayload(field string) error {
-	return fmt.Errorf("%s response missing payload; the API may have rejected the request", field)
-}

package/internal/defensivemode/api_test.go

@@ -1,122 +0,0 @@
-package defensivemode
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/Khan/genqlient/graphql"
-)
-
-func newGQLClient(srv *httptest.Server) graphql.Client {
-	return graphql.NewClient(srv.URL+"/graphql", srv.Client())
-}
-
-func TestUpdateDefensiveModeStatusBuildsCorrectRequest(t *testing.T) {
-	var gotBody string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		b, _ := io.ReadAll(r.Body)
-		gotBody = string(b)
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"data":{"updateDefensiveModeStatus":{"success":true,"message":"ok"}}}`))
-	}))
-	defer srv.Close()
-	c := newGQLClient(srv)
-	result, err := UpdateDefensiveModeStatus(context.Background(), c, UpdateStatusInput{
-		AppID:   42,
-		EnvID:   7,
-		Enabled: true,
-	})
-	if err != nil {
-		t.Fatalf("UpdateDefensiveModeStatus: %v", err)
-	}
-	if !result.Success || result.Message != "ok" {
-		t.Errorf("result = %+v", result)
-	}
-	if !strings.Contains(gotBody, `"operationName":"UpdateDefensiveModeStatus"`) {
-		t.Errorf("operationName missing: %s", gotBody)
-	}
-	// Verify the wire shape uses id / environmentId / enabled keys.
-	for _, want := range []string{`"id":42`, `"environmentId":7`, `"enabled":true`} {
-		if !strings.Contains(gotBody, want) {
-			t.Errorf("expected %q in body; got %s", want, gotBody)
-		}
-	}
-}
-
-func TestUpdateDefensiveModeConfigOmitsUnsetThresholds(t *testing.T) {
-	var gotBody string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		b, _ := io.ReadAll(r.Body)
-		gotBody = string(b)
-		_, _ = w.Write([]byte(`{"data":{"updateDefensiveModeConfig":{"success":true,"message":"ok"}}}`))
-	}))
-	defer srv.Close()
-	c := newGQLClient(srv)
-	_, err := UpdateDefensiveModeConfig(context.Background(), c, UpdateConfigInput{
-		AppID:         42,
-		EnvID:         7,
-		Enabled:       true,
-		ChallengeType: 1,
-	})
-	if err != nil {
-		t.Fatalf("UpdateDefensiveModeConfig: %v", err)
-	}
-	// Optional thresholds: when nil on the Go side, they should serialize as
-	// null on the wire (genqlient pointer optionals are encoded that way),
-	// not omitted entirely. The schema accepts null for these fields.
-	// The important property: don't send a NON-null integer for a threshold
-	// the user didn't set. Look for the substring "5000" / "80" which would
-	// indicate a leaked value.
-	if strings.Contains(gotBody, "5000") {
-		t.Errorf("unset absolute threshold leaked: %s", gotBody)
-	}
-	if strings.Contains(gotBody, ",80,") || strings.Contains(gotBody, ":80}") {
-		t.Errorf("unset percentage threshold leaked: %s", gotBody)
-	}
-}
-
-func TestUpdateDefensiveModeConfigIncludesSetThresholds(t *testing.T) {
-	var gotBody string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		b, _ := io.ReadAll(r.Body)
-		gotBody = string(b)
-		_, _ = w.Write([]byte(`{"data":{"updateDefensiveModeConfig":{"success":true,"message":"ok"}}}`))
-	}))
-	defer srv.Close()
-	c := newGQLClient(srv)
-	abs := 5000
-	pct := 80
-	_, err := UpdateDefensiveModeConfig(context.Background(), c, UpdateConfigInput{
-		AppID:                         42,
-		EnvID:                         7,
-		Enabled:                       true,
-		ChallengeType:                 2,
-		ConnectionThresholdAbsolute:   &abs,
-		ConnectionThresholdPercentage: &pct,
-	})
-	if err != nil {
-		t.Fatalf("UpdateDefensiveModeConfig: %v", err)
-	}
-	if !strings.Contains(gotBody, `"connectionThresholdAbsolute":5000`) {
-		t.Errorf("absolute threshold missing: %s", gotBody)
-	}
-	if !strings.Contains(gotBody, `"connectionThresholdPercentage":80`) {
-		t.Errorf("percentage threshold missing: %s", gotBody)
-	}
-}
-
-func TestUpdateDefensiveModeReturnsErrorWhenNoPayload(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"updateDefensiveModeStatus":null}}`))
-	}))
-	defer srv.Close()
-	c := newGQLClient(srv)
-	_, err := UpdateDefensiveModeStatus(context.Background(), c, UpdateStatusInput{AppID: 1, EnvID: 1, Enabled: true})
-	if err == nil {
-		t.Error("expected error when payload is null")
-	}
-}

package/internal/devenv/adapters.go

@@ -1,168 +0,0 @@
-package devenv
-
-import (
-	"context"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/Automattic/vip/internal/devenv/dockercli"
-	"github.com/Automattic/vip/internal/devenv/hostops"
-	"github.com/Automattic/vip/internal/devenv/lifecycle"
-	"github.com/Automattic/vip/internal/devenv/proxy"
-	"github.com/Automattic/vip/internal/httpproxy"
-)
-
-// dockerAdapter satisfies lifecycle.Docker using the real *dockercli.Runner.
-type dockerAdapter struct{ r *dockercli.Runner }
-
-func (a dockerAdapter) Compose(ctx context.Context, project string, args ...string) error {
-	return a.r.Compose(ctx, project, args...)
-}
-func (a dockerAdapter) ComposePS(ctx context.Context, project string) ([]lifecycle.ServiceState, error) {
-	raw, err := a.r.ComposePS(ctx, project)
-	if err != nil {
-		return nil, err
-	}
-	out := make([]lifecycle.ServiceState, len(raw))
-	for i, s := range raw {
-		out[i] = lifecycle.ServiceState{Service: s.Service, State: s.State, ExitCode: s.ExitCode}
-	}
-	return out, nil
-}
-func (a dockerAdapter) ListVolumes(ctx context.Context) ([]string, error) {
-	b, err := a.r.DockerOut(ctx, "volume", "ls", "--format", "{{.Name}}")
-	if err != nil {
-		return nil, err
-	}
-	return parseVolumeLines(b), nil
-}
-
-// parseVolumeLines splits `docker volume ls --format {{.Name}}` output into names,
-// dropping the trailing newline and any blank lines.
-func parseVolumeLines(b []byte) []string {
-	var names []string
-	for _, line := range strings.Split(strings.TrimRight(string(b), "\n"), "\n") {
-		if line != "" {
-			names = append(names, line)
-		}
-	}
-	return names
-}
-
-func (a dockerAdapter) ListContainers(ctx context.Context, filters ...string) ([]lifecycle.Container, error) {
-	args := []string{"ps", "-a", "--format", "{{.ID}}\t{{.Names}}"}
-	for _, f := range filters {
-		args = append(args, "--filter", f)
-	}
-	b, err := a.r.DockerOut(ctx, args...)
-	if err != nil {
-		return nil, err
-	}
-	return parseContainerLines(b), nil
-}
-
-// parseContainerLines splits `docker ps --format {{.ID}}\t{{.Names}}` output into
-// Containers, dropping the trailing newline and any blank lines.
-func parseContainerLines(b []byte) []lifecycle.Container {
-	var out []lifecycle.Container
-	for _, line := range strings.Split(strings.TrimRight(string(b), "\n"), "\n") {
-		if line == "" {
-			continue
-		}
-		parts := strings.SplitN(line, "\t", 2)
-		c := lifecycle.Container{ID: parts[0]}
-		if len(parts) > 1 {
-			c.Name = parts[1]
-		}
-		out = append(out, c)
-	}
-	return out
-}
-
-// proxyAdapter binds the proxy package funcs to the lifecycle.Proxy interface,
-// carrying the runner so each call uses the real DockerRunner.
-type proxyAdapter struct{ r *dockercli.Runner }
-
-func (a proxyAdapter) Ensure(ctx context.Context, o proxy.EnsureOptions) (proxy.Ports, error) {
-	return proxy.Ensure(ctx, a.r, o)
-}
-func (a proxyAdapter) EnsureCA(ctx context.Context) error { return proxy.EnsureCA(ctx, a.r) }
-func (a proxyAdapter) EnsureCert(ctx context.Context, req proxy.CertRequest) error {
-	return proxy.EnsureCert(ctx, a.r, req)
-}
-func (a proxyAdapter) ExtractCA(ctx context.Context, dest string) (string, error) {
-	return proxy.ExtractCA(ctx, a.r, dest)
-}
-func (a proxyAdapter) Cleanup(ctx context.Context) error      { return proxy.Cleanup(ctx, a.r) }
-func (a proxyAdapter) RemoveOrphan(ctx context.Context) error { return proxy.RemoveOrphan(ctx, a.r) }
-func (a proxyAdapter) ForceRemove(ctx context.Context) error  { return proxy.ForceRemove(ctx, a.r) }
-
-// elevatorAdapter / httpProber are trivial real impls.
-type elevatorAdapter struct{}
-
-func (elevatorAdapter) Apply(plan hostops.PrivilegedPlan) error { return hostops.Apply(plan) }
-func (elevatorAdapter) CATrusted(caPath string) bool {
-	return hostops.CATrusted(runtime.GOOS, caPath)
-}
-func (elevatorAdapter) HostsPresent(hosts []string) bool { return hostops.HostsPresent(hosts) }
-
-type httpProber struct{}
-
-// Probe fetches the environment's own front-end URL, e.g.
-// https://<slug>.vipdev.site/, which /etc/hosts maps to 127.0.0.1 on THIS
-// machine. It must never be proxied: httpproxy.ProxyURL honours VIP_PROXY
-// unconditionally and exempts no loopback (matching Node's proxy-from-env), so
-// the policy client would hand this hostname to the developer's SOCKS proxy to
-// resolve and dial on the proxy's side, where the containers do not exist. Node
-// does not proxy it either — Lando's health check is internal, and the only
-// dev-environment request Node routes through createProxyAgent is the WordPress
-// version manifest (dev-environment-core.ts:1044).
-func (httpProber) Probe(url string) (int, error) {
-	c := httpproxy.DirectClientWithTimeout(5 * time.Second)
-	resp, err := c.Get(url)
-	if err != nil {
-		return 0, err
-	}
-	defer resp.Body.Close()
-	return resp.StatusCode, nil
-}
-
-// subsiteAdapter lists multisite subsite domains via `wp site list` on the php
-// container. Satisfies lifecycle.SubsiteLister.
-type subsiteAdapter struct{ r *dockercli.Runner }
-
-func (a subsiteAdapter) ListSubsiteDomains(ctx context.Context, project, service string) ([]string, error) {
-	out, err := a.r.ComposeOut(ctx, project,
-		"exec", "-T", "-u", "www-data", service,
-		"wp", "--allow-root", "site", "list", "--fields=domain", "--format=csv")
-	if err != nil {
-		return nil, err
-	}
-	return parseSiteListCSV(out), nil
-}
-
-// parseSiteListCSV extracts the domain column from `wp site list --fields=domain
-// --format=csv` output (a header line "domain" followed by one domain per line).
-func parseSiteListCSV(out []byte) []string {
-	var domains []string
-	for _, ln := range strings.Split(string(out), "\n") {
-		ln = strings.TrimSpace(strings.Trim(ln, "\r"))
-		if ln == "" || ln == "domain" {
-			continue
-		}
-		domains = append(domains, ln)
-	}
-	return domains
-}
-
-// realDeps assembles the production lifecycle.Deps around a runner.
-func realDeps(r *dockercli.Runner) lifecycle.Deps {
-	return lifecycle.Deps{
-		Docker:   dockerAdapter{r: r},
-		Proxy:    proxyAdapter{r: r},
-		Elevator: elevatorAdapter{},
-		Prober:   httpProber{},
-		Subsites: subsiteAdapter{r: r},
-	}
-}

package/internal/devenv/adapters_test.go

@@ -1,44 +0,0 @@
-package devenv
-
-import "testing"
-
-func TestParseVolumeLines(t *testing.T) {
-	got := parseVolumeLines([]byte("alpha\nbeta\n\ngamma\n"))
-	want := []string{"alpha", "beta", "gamma"}
-	if len(got) != len(want) {
-		t.Fatalf("got %v, want %v", got, want)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Fatalf("got %v, want %v", got, want)
-		}
-	}
-	if len(parseVolumeLines([]byte(""))) != 0 {
-		t.Fatal("empty input should yield no names")
-	}
-}
-
-func TestParseSiteListCSV(t *testing.T) {
-	csv := "domain\nnet.vipdev.site\nsub1.net.vipdev.site\nsub2.net.vipdev.site\n"
-	got := parseSiteListCSV([]byte(csv))
-	want := []string{"net.vipdev.site", "sub1.net.vipdev.site", "sub2.net.vipdev.site"}
-	if len(got) != len(want) {
-		t.Fatalf("parseSiteListCSV = %v, want %v", got, want)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Fatalf("row %d = %q, want %q", i, got[i], want[i])
-		}
-	}
-}
-
-func TestParseContainerLines(t *testing.T) {
-	raw := []byte("abc123\texample_php_1\ndef456\texample_database_1\n\n")
-	got := parseContainerLines(raw)
-	if len(got) != 2 {
-		t.Fatalf("want 2 containers, got %+v", got)
-	}
-	if got[0].ID != "abc123" || got[0].Name != "example_php_1" {
-		t.Fatalf("bad parse: %+v", got[0])
-	}
-}

package/internal/devenv/adopt.go

@@ -1,20 +0,0 @@
-package devenv
-
-import "github.com/Automattic/vip/internal/devenv/compose"
-
-// adoptSetupSteps prepends a one-time recursive chown when a start is adopting a
-// pre-existing Lando environment. The reused NoCopy volumes (mu-plugins, and the
-// image-mode client-code content) keep Lando's file ownership, so setup.sh — run
-// as www-data — cannot overwrite pre-existing root-owned files like
-// dev-env-plugin.php in the mu-plugins volume (the base chown is non-recursive:
-// it fixes the mount-point dirs, not their contents). Normalizing /wp/wp-content
-// to www-data once, as root, before setup.sh runs, fixes it. Greenfield starts
-// pass adopting=false, so this never adds per-start cost.
-func adoptSetupSteps(base []compose.SetupStep, adopting bool) []compose.SetupStep {
-	if !adopting {
-		return base
-	}
-	return append([]compose.SetupStep{
-		{AsRoot: true, Command: "chown -R www-data:www-data /wp/wp-content"},
-	}, base...)
-}

package/internal/devenv/adopt_setup_test.go

@@ -1,30 +0,0 @@
-package devenv
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/compose"
-)
-
-func TestAdoptSetupStepsPrependsRecursiveChownWhenAdopting(t *testing.T) {
-	base := []compose.SetupStep{{AsRoot: false, Command: "sh /dev-tools/setup.sh"}}
-
-	if got := adoptSetupSteps(base, false); len(got) != 1 {
-		t.Fatalf("non-adopting start must be unchanged, got %+v", got)
-	}
-
-	got := adoptSetupSteps(base, true)
-	if len(got) != 2 {
-		t.Fatalf("adopting start must prepend one step, got %+v", got)
-	}
-	if !got[0].AsRoot || !strings.Contains(got[0].Command, "chown -R www-data:www-data /wp/wp-content") {
-		t.Fatalf("want a recursive root chown first, got %+v", got[0])
-	}
-	if got[1].Command != base[0].Command {
-		t.Fatalf("original setup steps must follow, got %+v", got[1])
-	}
-	if len(base) != 1 {
-		t.Fatal("base slice must not be mutated")
-	}
-}

package/internal/devenv/compose/labels.go

@@ -1,90 +0,0 @@
-package compose
-
-import (
-	"fmt"
-	"strings"
-)
-
-// hostRule builds a Traefik HostRegexp rule for a hostname, converting a "*"
-// wildcard to the [a-z0-9-]+ class (ports lando-proxy/lib/utils.js getRule).
-func hostRule(host string) string {
-	re := strings.ReplaceAll(host, "*", "[a-z0-9-]+")
-	return fmt.Sprintf("HostRegexp(`%s`)", re)
-}
-
-// routerLabels emits an http router + a tls (secured) router for one routed
-// hostname pattern on a given service port, all prefixed by id.
-func routerLabels(id, rule string, port int, labels map[string]string) {
-	labels[fmt.Sprintf("traefik.http.routers.%s.entrypoints", id)] = "http"
-	labels[fmt.Sprintf("traefik.http.routers.%s.rule", id)] = rule
-	labels[fmt.Sprintf("traefik.http.routers.%s.service", id)] = id + "-service"
-	labels[fmt.Sprintf("traefik.http.services.%s-service.loadbalancer.server.port", id)] = fmt.Sprintf("%d", port)
-
-	sec := id + "-secured"
-	labels[fmt.Sprintf("traefik.http.routers.%s.entrypoints", sec)] = "https"
-	labels[fmt.Sprintf("traefik.http.routers.%s.rule", sec)] = rule
-	labels[fmt.Sprintf("traefik.http.routers.%s.tls", sec)] = "true"
-	labels[fmt.Sprintf("traefik.http.routers.%s.service", sec)] = sec + "-service"
-	// Build the secured service key from id (not sec) so it resolves to
-	// "<id>-secured-service" — matching the router .service pointer above and
-	// Node's ${rule.id}-secured-service (utils.js:205). Using sec here would
-	// yield "<id>-secured-secured-service" and silently break TLS routing.
-	labels[fmt.Sprintf("traefik.http.services.%s-secured-service.loadbalancer.server.port", id)] = fmt.Sprintf("%d", port)
-}
-
-// nginxLabels routes the front-end hostname(s) to the nginx service, adding the
-// multisite wildcard host when enabled. The nginx image listens on port 80 (its
-// listen directive + the EJS proxy entry, which has no explicit port → Lando's
-// default 80); routing Traefik to 8080 yields a 502 since nothing listens there.
-func nginxLabels(v View) map[string]string {
-	labels := map[string]string{"traefik.enable": "true"}
-	base := v.SiteSlug + "." + v.Domain
-	routerLabels("nginx-"+v.SiteSlug, hostRule(base), 80, labels)
-	if v.MultisiteEnabled {
-		routerLabels("nginx-"+v.SiteSlug+"-wild", hostRule("*."+base), 80, labels)
-	}
-	return labels
-}
-
-// phpMyAdminLabels routes <slug>-pma.<domain> to phpmyadmin (port 80).
-func phpMyAdminLabels(v View) map[string]string {
-	labels := map[string]string{"traefik.enable": "true"}
-	routerLabels("pma-"+v.SiteSlug, hostRule(v.SiteSlug+"-pma."+v.Domain), 80, labels)
-	return labels
-}
-
-// mailpitLabels routes <slug>-mailpit.<domain> to mailpit (port 8025).
-func mailpitLabels(v View) map[string]string {
-	labels := map[string]string{"traefik.enable": "true"}
-	routerLabels("mailpit-"+v.SiteSlug, hostRule(v.SiteSlug+"-mailpit."+v.Domain), 8025, labels)
-	return labels
-}
-
-// CertSANs returns the hostnames needing a TLS cert for this environment — the
-// set that gets secured (https/tls) Traefik routers above. These SANs are the
-// single source of truth for the env's edge certificate: the proxy package
-// generates one leaf cert covering them centrally (proxy.EnsureCert), because
-// the traefik_openssl image runs no in-service cert machinery (Task 1 findings).
-// Consequently the app services carry no cert env or certs volume — TLS
-// terminates at the Traefik edge using the file-provider cert built from this list.
-func CertSANs(v View) []string {
-	// Lead with a base-domain wildcard (like Lando's *.lndo.site) so the cert
-	// covers this env's host AND any one-label subdomain of the base domain —
-	// every <slug>.<domain>, the -pma/-mailpit hosts, and sibling envs — without
-	// per-host SANs. The explicit hosts below remain for clarity/exactness, and
-	// the deeper multisite wildcard (two labels) is still added separately.
-	sans := []string{
-		"*." + v.Domain,
-		v.SiteSlug + "." + v.Domain,
-	}
-	if v.MultisiteEnabled {
-		sans = append(sans, "*."+v.SiteSlug+"."+v.Domain)
-	}
-	if v.PHPMyAdmin {
-		sans = append(sans, v.SiteSlug+"-pma."+v.Domain)
-	}
-	if v.Mailpit {
-		sans = append(sans, v.SiteSlug+"-mailpit."+v.Domain)
-	}
-	return sans
-}