github.com/supabase/cli@v1.168.1/internal/status/status.go

package status

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"reflect"

	"github.com/docker/docker/client"
	"github.com/go-errors/errors"
	"github.com/spf13/afero"
	"github.com/supabase/cli/internal/utils"
)

type CustomName struct {
	ApiURL                   string `env:"api.url,default=API_URL"`
	GraphqlURL               string `env:"api.graphql_url,default=GRAPHQL_URL"`
	StorageS3URL             string `env:"api.storage_s3_url,default=STORAGE_S3_URL"`
	DbURL                    string `env:"db.url,default=DB_URL"`
	StudioURL                string `env:"studio.url,default=STUDIO_URL"`
	InbucketURL              string `env:"inbucket.url,default=INBUCKET_URL"`
	JWTSecret                string `env:"auth.jwt_secret,default=JWT_SECRET"`
	AnonKey                  string `env:"auth.anon_key,default=ANON_KEY"`
	ServiceRoleKey           string `env:"auth.service_role_key,default=SERVICE_ROLE_KEY"`
	StorageS3AccessKeyId     string `env:"storage.s3_access_key_id,default=S3_PROTOCOL_ACCESS_KEY_ID"`
	StorageS3SecretAccessKey string `env:"storage.s3_secret_access_key,default=S3_PROTOCOL_ACCESS_KEY_SECRET"`
	StorageS3Region          string `env:"storage.s3_region,default=S3_PROTOCOL_REGION"`
}

func (c *CustomName) toValues(exclude ...string) map[string]string {
	values := map[string]string{
		c.DbURL: fmt.Sprintf("postgresql://%s@%s:%d/postgres", url.UserPassword("postgres", utils.Config.Db.Password), utils.Config.Hostname, utils.Config.Db.Port),
	}
	if utils.Config.Api.Enabled && !utils.SliceContains(exclude, utils.RestId) && !utils.SliceContains(exclude, utils.ShortContainerImageName(utils.Config.Api.Image)) {
		values[c.ApiURL] = fmt.Sprintf("http://%s:%d", utils.Config.Hostname, utils.Config.Api.Port)
		values[c.GraphqlURL] = fmt.Sprintf("http://%s:%d/graphql/v1", utils.Config.Hostname, utils.Config.Api.Port)
	}
	if utils.Config.Studio.Enabled && !utils.SliceContains(exclude, utils.StudioId) && !utils.SliceContains(exclude, utils.ShortContainerImageName(utils.StudioImage)) {
		values[c.StudioURL] = fmt.Sprintf("http://%s:%d", utils.Config.Hostname, utils.Config.Studio.Port)
	}
	if utils.Config.Auth.Enabled && !utils.SliceContains(exclude, utils.GotrueId) && !utils.SliceContains(exclude, utils.ShortContainerImageName(utils.Config.Auth.Image)) {
		values[c.JWTSecret] = utils.Config.Auth.JwtSecret
		values[c.AnonKey] = utils.Config.Auth.AnonKey
		values[c.ServiceRoleKey] = utils.Config.Auth.ServiceRoleKey
	}
	if utils.Config.Inbucket.Enabled && !utils.SliceContains(exclude, utils.InbucketId) && !utils.SliceContains(exclude, utils.ShortContainerImageName(utils.InbucketImage)) {
		values[c.InbucketURL] = fmt.Sprintf("http://%s:%d", utils.Config.Hostname, utils.Config.Inbucket.Port)
	}
	if utils.Config.Storage.Enabled && !utils.SliceContains(exclude, utils.StorageId) && !utils.SliceContains(exclude, utils.ShortContainerImageName(utils.Config.Storage.Image)) {
		values[c.StorageS3URL] = fmt.Sprintf("http://%s:%d/storage/v1/s3", utils.Config.Hostname, utils.Config.Api.Port)
		values[c.StorageS3AccessKeyId] = utils.Config.Storage.S3Credentials.AccessKeyId
		values[c.StorageS3SecretAccessKey] = utils.Config.Storage.S3Credentials.SecretAccessKey
		values[c.StorageS3Region] = utils.Config.Storage.S3Credentials.Region
	}
	return values
}

func Run(ctx context.Context, names CustomName, format string, fsys afero.Fs) error {
	// Sanity checks.
	{
		if err := utils.LoadConfigFS(fsys); err != nil {
			return err
		}
		if err := AssertContainerHealthy(ctx, utils.DbId); err != nil {
			return err
		}
	}

	services := []string{
		utils.KongId,
		utils.GotrueId,
		utils.InbucketId,
		utils.RealtimeId,
		utils.RestId,
		utils.StorageId,
		utils.ImgProxyId,
		utils.PgmetaId,
		utils.StudioId,
		utils.LogflareId,
	}
	stopped := checkServiceHealth(ctx, services, os.Stderr)
	if len(stopped) > 0 {
		fmt.Fprintln(os.Stderr, "Stopped services:", stopped)
	}
	if format == utils.OutputPretty {
		fmt.Fprintf(os.Stderr, "%s local development setup is running.\n\n", utils.Aqua("supabase"))
		PrettyPrint(os.Stdout, stopped...)
		return nil
	}
	return printStatus(names, format, os.Stdout, stopped...)
}

func checkServiceHealth(ctx context.Context, services []string, w io.Writer) (stopped []string) {
	for _, name := range services {
		if err := AssertContainerHealthy(ctx, name); err != nil {
			if client.IsErrNotFound(err) {
				stopped = append(stopped, name)
			} else {
				// Log unhealthy containers instead of failing
				fmt.Fprintln(w, err)
			}
		}
	}
	return stopped
}

func AssertContainerHealthy(ctx context.Context, container string) error {
	if resp, err := utils.Docker.ContainerInspect(ctx, container); err != nil {
		return err
	} else if !resp.State.Running {
		return errors.Errorf("%s container is not running: %s", container, resp.State.Status)
	} else if resp.State.Health != nil && resp.State.Health.Status != "healthy" {
		return errors.Errorf("%s container is not ready: %s", container, resp.State.Health.Status)
	}
	return nil
}

func IsServiceReady(ctx context.Context, container string) bool {
	if container == utils.RestId {
		return isPostgRESTHealthy(ctx)
	}
	if container == utils.EdgeRuntimeId {
		return isEdgeRuntimeHealthy(ctx)
	}
	return AssertContainerHealthy(ctx, container) == nil
}

func isPostgRESTHealthy(ctx context.Context) bool {
	// PostgREST does not support native health checks
	restUrl := fmt.Sprintf("http://%s:%d/rest-admin/v1/ready", utils.Config.Hostname, utils.Config.Api.Port)
	return checkHTTPHead(ctx, restUrl)
}

func isEdgeRuntimeHealthy(ctx context.Context) bool {
	// Native health check logs too much hyper::Error(IncompleteMessage)
	restUrl := fmt.Sprintf("http://%s:%d/functions/v1/_internal/health", utils.Config.Hostname, utils.Config.Api.Port)
	return checkHTTPHead(ctx, restUrl)
}

func checkHTTPHead(ctx context.Context, url string) bool {
	req, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)
	if err != nil {
		return false
	}
	req.Header.Add("apikey", utils.Config.Auth.AnonKey)
	resp, err := http.DefaultClient.Do(req)
	return err == nil && resp.StatusCode == http.StatusOK
}

func printStatus(names CustomName, format string, w io.Writer, exclude ...string) (err error) {
	values := names.toValues(exclude...)
	return utils.EncodeOutput(format, w, values)
}

func PrettyPrint(w io.Writer, exclude ...string) {
	names := CustomName{
		ApiURL:                   "         " + utils.Aqua("API URL"),
		GraphqlURL:               "     " + utils.Aqua("GraphQL URL"),
		StorageS3URL:             "  " + utils.Aqua("S3 Storage URL"),
		DbURL:                    "          " + utils.Aqua("DB URL"),
		StudioURL:                "      " + utils.Aqua("Studio URL"),
		InbucketURL:              "    " + utils.Aqua("Inbucket URL"),
		JWTSecret:                "      " + utils.Aqua("JWT secret"),
		AnonKey:                  "        " + utils.Aqua("anon key"),
		ServiceRoleKey:           "" + utils.Aqua("service_role key"),
		StorageS3AccessKeyId:     "   " + utils.Aqua("S3 Access Key"),
		StorageS3SecretAccessKey: "   " + utils.Aqua("S3 Secret Key"),
		StorageS3Region:          "       " + utils.Aqua("S3 Region"),
	}
	values := names.toValues(exclude...)
	// Iterate through map in order of declared struct fields
	val := reflect.ValueOf(names)
	for i := 0; i < val.NumField(); i++ {
		k := val.Field(i).String()
		if v, ok := values[k]; ok {
			fmt.Fprintf(w, "%s: %s\n", k, v)
		}
	}
}