main.go

// cloudrun-mvp is a minimal CLI that demonstrates the core CLOUDRUN_SYNC deployment flow:
// load service.yaml → compute revision name → mutate manifest → call GCP Cloud Run API → poll readiness.
//
// This is the same logic that will live inside ExecuteStage() for the CLOUDRUN_SYNC stage
// in the PipeCD v1 Cloud Run plugin (pkg/app/pipedv1/plugin/cloudrun/deployment/).
//
// Usage:
//
//	go run . --project=<gcp-project> --region=<region> [--service-yaml=service.yaml] \
//	          [--credentials-file=key.json] [--commit-hash=<hash>]
//
// Authentication:
//
//	If --credentials-file is omitted, Application Default Credentials are used.
//	Run `gcloud auth application-default login` to set up ADC locally.
package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"math/rand"
	"os"
	"time"
)

// PipeCD tracking labels — same constants used in v0 platformprovider/cloudrun/cloudrun.go.
const (
	labelManagedBy    = "pipecd-dev-managed-by"
	labelCommitHash   = "pipecd-dev-commit-hash"
	labelRevisionName = "pipecd-dev-revision-name"
	managedByPiped    = "piped"
)

func main() {
	var (
		project         = flag.String("project", "", "GCP project ID (required)")
		region          = flag.String("region", "us-central1", "Cloud Run region")
		serviceYAML     = flag.String("service-yaml", "service.yaml", "Path to service.yaml manifest")
		credentialsFile = flag.String("credentials-file", "", "Path to GCP service account JSON key (uses ADC if omitted)")
		commitHash      = flag.String("commit-hash", "", "Commit hash for deterministic revision naming (uses random 7-char hash if omitted)")
	)
	flag.Parse()

	if *project == "" {
		fmt.Fprintln(os.Stderr, "error: --project is required")
		flag.Usage()
		os.Exit(1)
	}

	if *commitHash == "" {
		*commitHash = randomHash()
	}

	log.SetFlags(log.Ltime)
	logf := func(format string, args ...interface{}) {
		log.Printf(format, args...)
	}

	ctx := context.Background()

	// ── Step 1: Load the service manifest ──────────────────────────────────────
	logf("[CLOUDRUN_SYNC] Loading service manifest: %s", *serviceYAML)
	sm, err := LoadServiceManifest(*serviceYAML)
	if err != nil {
		logf("[CLOUDRUN_SYNC] ERROR: %v", err)
		os.Exit(1)
	}
	logf("[CLOUDRUN_SYNC] Loaded manifest for service: %q", sm.Name)

	// ── Step 2: Compute deterministic revision name ─────────────────────────────
	// Format: "<service>-<tag>-<short-commit>"  e.g. "hello-cloudrun-latest-abc1234"
	revisionName, err := DecideRevisionName(sm, *commitHash)
	if err != nil {
		logf("[CLOUDRUN_SYNC] ERROR computing revision name: %v", err)
		os.Exit(1)
	}
	logf("[CLOUDRUN_SYNC] Computed revision name: %s", revisionName)

	// ── Step 3: Mutate the manifest ─────────────────────────────────────────────
	logf("[CLOUDRUN_SYNC] Setting revision name in manifest")
	if err := sm.SetRevision(revisionName); err != nil {
		logf("[CLOUDRUN_SYNC] ERROR: %v", err)
		os.Exit(1)
	}

	logf("[CLOUDRUN_SYNC] Setting traffic: [%s → 100%%]", revisionName)
	if err := sm.UpdateTraffic([]RevisionTraffic{
		{RevisionName: revisionName, Percent: 100},
	}); err != nil {
		logf("[CLOUDRUN_SYNC] ERROR: %v", err)
		os.Exit(1)
	}

	labels := map[string]string{
		labelManagedBy:    managedByPiped,
		labelCommitHash:   *commitHash,
		labelRevisionName: revisionName,
	}
	sm.AddLabels(labels)
	if err := sm.AddRevisionLabels(labels); err != nil {
		logf("[CLOUDRUN_SYNC] ERROR adding revision labels: %v", err)
		os.Exit(1)
	}
	logf("[CLOUDRUN_SYNC] PipeCD tracking labels applied")

	// ── Step 4: Create the GCP client ──────────────────────────────────────────
	logf("[CLOUDRUN_SYNC] Initializing Cloud Run client (project=%s, region=%s)", *project, *region)
	client, err := NewClient(ctx, *project, *region, *credentialsFile)
	if err != nil {
		logf("[CLOUDRUN_SYNC] ERROR: %v", err)
		os.Exit(1)
	}

	// ── Step 5: Apply the manifest (Create or Update) ──────────────────────────
	logf("[CLOUDRUN_SYNC] Applying service manifest to Cloud Run API...")
	created, err := client.CreateOrUpdate(ctx, sm)
	if err != nil {
		logf("[CLOUDRUN_SYNC] ERROR applying manifest: %v", err)
		os.Exit(1)
	}
	if created {
		logf("[CLOUDRUN_SYNC] Service %q created (first deployment)", sm.Name)
	} else {
		logf("[CLOUDRUN_SYNC] Service %q updated", sm.Name)
	}

	// ── Step 6: Poll until revision is ready ───────────────────────────────────
	logf("[CLOUDRUN_SYNC] Polling revision %s for readiness (timeout: 2m, interval: 10s)...", revisionName)
	if err := client.WaitRevisionReady(ctx, revisionName, logf); err != nil {
		logf("[CLOUDRUN_SYNC] ERROR: %v", err)
		os.Exit(1)
	}

	// ── Done ───────────────────────────────────────────────────────────────────
	logf("[CLOUDRUN_SYNC] SUCCESS — service %q is running revision %s with 100%% traffic", sm.Name, revisionName)
}

func randomHash() string {
	const chars = "abcdef0123456789"
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	b := make([]byte, 7)
	for i := range b {
		b[i] = chars[r.Intn(len(chars))]
	}
	return string(b)
}