diff --git a/deployment/docker-compose.yaml b/deployment/docker-compose.yaml index 571022bba2..3b339afe02 100644 --- a/deployment/docker-compose.yaml +++ b/deployment/docker-compose.yaml @@ -69,26 +69,6 @@ services: OTEL_EXPORTER_OTLP_PROTOCOL: "http/protobuf" # UNKEY_PROMETHEUS_PORT: 2112 - ctrl: - container_name: ctrl - command: ["run", "ctrl"] - build: - context: ../go - dockerfile: ./Dockerfile - depends_on: - - mysql - - otel - ports: - - "7091:7091" - environment: - UNKEY_HTTP_PORT: 7091 - UNKEY_DATABASE_PRIMARY: "unkey:password@tcp(mysql:3306)/unkey?parseTime=true" - UNKEY_DATABASE_HYDRA: "unkey:password@tcp(mysql:3306)/hydra?parseTime=true" - UNKEY_OTEL: true - OTEL_EXPORTER_OTLP_ENDPOINT: "http://otel:4318" - OTEL_EXPORTER_OTLP_PROTOCOL: "http/protobuf" - UNKEY_AUTH_TOKEN: "ctrl-secret-token" - redis: container_name: redis image: redis:latest @@ -201,6 +181,29 @@ services: - clickhouse - chproxy + ctrl: + build: + context: ../go + dockerfile: Dockerfile + args: + VERSION: "latest" + container_name: unkey-ctrl + command: ["run", "ctrl"] + ports: + - "7091:7091" + depends_on: + - mysql + environment: + # Database configuration - use existing mysql service + UNKEY_DATABASE_PRIMARY: "unkey:password@tcp(mysql:3306)/unkey?parseTime=true" + UNKEY_DATABASE_HYDRA: "unkey:password@tcp(mysql:3306)/hydra?parseTime=true" + + # Control plane configuration + UNKEY_HTTP_PORT: "7091" + UNKEY_METALD_ADDRESS: "http://localhost:8080" + + # Override the entrypoint to run ctrl command + otel: image: grafana/otel-lgtm:latest container_name: otel diff --git a/go/Dockerfile b/go/Dockerfile index 492b13c349..a11a67fa68 100644 --- a/go/Dockerfile +++ b/go/Dockerfile @@ -1,10 +1,10 @@ FROM golang:1.24 AS builder WORKDIR /go/src/github.com/unkeyed/unkey/go -COPY go.sum go.mod ./ -RUN go mod download - +# Copy everything first because go.mod has replace directives pointing to ./deploy/pkg/ modules +# This ensures all local dependencies are available before go mod download COPY . . +RUN go mod download ARG VERSION ENV CGO_ENABLED=0 RUN go build -o bin/unkey -ldflags="-X 'github.com/unkeyed/unkey/go/pkg/version.Version=${VERSION}'" ./main.go diff --git a/go/apps/api/openapi/gen.go b/go/apps/api/openapi/gen.go index e637ddf6d0..20c8fef1b2 100644 --- a/go/apps/api/openapi/gen.go +++ b/go/apps/api/openapi/gen.go @@ -1579,7 +1579,7 @@ type V2KeysUpdateCreditsRequestBody struct { // Key behaviors: // - This completely replaces the current remaining credits value when operation is set to 'set' // - To add credits, either replace the current value with the new value or increment the current value by a new value - // - To make a key unlimited, set remaining = null + // - To make a key unlimited, set value = null // - To make a key with unlimited usage have a specific limit, set remaining to a positive number // - If a decrement would result in a negative value, the remaining credits are set to zero // - Credits are decremented each time the key is successfully verified (by the cost value, default 1) diff --git a/go/apps/ctrl/run.go b/go/apps/ctrl/run.go index 2f23aef4b8..ad8e2ef17f 100644 --- a/go/apps/ctrl/run.go +++ b/go/apps/ctrl/run.go @@ -8,10 +8,12 @@ import ( "log/slog" + "connectrpc.com/connect" "github.com/unkeyed/unkey/go/apps/ctrl/services/ctrl" "github.com/unkeyed/unkey/go/apps/ctrl/services/version" + deployTLS "github.com/unkeyed/unkey/go/deploy/pkg/tls" "github.com/unkeyed/unkey/go/gen/proto/ctrl/v1/ctrlv1connect" - "github.com/unkeyed/unkey/go/pkg/builder" + "github.com/unkeyed/unkey/go/gen/proto/metal/vmprovisioner/v1/vmprovisionerv1connect" "github.com/unkeyed/unkey/go/pkg/db" "github.com/unkeyed/unkey/go/pkg/hydra" "github.com/unkeyed/unkey/go/pkg/otel" @@ -99,12 +101,48 @@ func Run(ctx context.Context, cfg Config) error { return fmt.Errorf("unable to create hydra worker: %w", err) } - // Create the mock builder service for demo - builderService := builder.NewMockService() + // Create metald client for VM operations + var httpClient *http.Client + var authMode string + + if cfg.SPIFFESocketPath != "" { + // Use SPIRE authentication when socket path is provided + tlsConfig := deployTLS.Config{ + Mode: deployTLS.ModeSPIFFE, + SPIFFESocketPath: cfg.SPIFFESocketPath, + } + + tlsProvider, err := deployTLS.NewProvider(ctx, tlsConfig) + if err != nil { + return fmt.Errorf("failed to create TLS provider for metald: %w", err) + } + + httpClient = tlsProvider.HTTPClient() + authMode = "SPIRE" + } else { + // Fall back to plain HTTP for local development + httpClient = &http.Client{} + authMode = "plain HTTP" + } + + httpClient.Timeout = 30 * time.Second + + metaldClient := vmprovisionerv1connect.NewVmServiceClient( + httpClient, + cfg.MetaldAddress, + connect.WithInterceptors(connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc { + return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) { + logger.Info("Adding auth headers to metald request", "procedure", req.Spec().Procedure) + req.Header().Set("Authorization", "Bearer dev_user_ctrl") + req.Header().Set("X-Tenant-ID", "ctrl-tenant") + return next(ctx, req) + } + })), + ) + logger.Info("metald client configured", "address", cfg.MetaldAddress, "auth_mode", authMode) // Register deployment workflow with Hydra worker - // TODO: Replace nil with actual metald client when available - deployWorkflow := version.NewDeployWorkflow(database, logger, builderService, nil) + deployWorkflow := version.NewDeployWorkflow(database, logger, metaldClient) err = hydra.RegisterWorkflow(hydraWorker, deployWorkflow) if err != nil { return fmt.Errorf("unable to register deployment workflow: %w", err) @@ -112,7 +150,7 @@ func Run(ctx context.Context, cfg Config) error { // Create the service implementations ctrlSvc := ctrl.New(cfg.InstanceID, database) - versionSvc := version.New(database, hydraEngine, builderService, logger) + versionSvc := version.New(database, hydraEngine, logger) // Create the connect handler mux := http.NewServeMux() diff --git a/go/apps/ctrl/services/version/deploy_workflow.go b/go/apps/ctrl/services/version/deploy_workflow.go index d5408d21f8..e1a4478d32 100644 --- a/go/apps/ctrl/services/version/deploy_workflow.go +++ b/go/apps/ctrl/services/version/deploy_workflow.go @@ -4,13 +4,13 @@ import ( "context" "database/sql" "fmt" + "strings" "time" - "connectrpc.com/connect" vmprovisionerv1 "github.com/unkeyed/unkey/go/gen/proto/metal/vmprovisioner/v1" "github.com/unkeyed/unkey/go/gen/proto/metal/vmprovisioner/v1/vmprovisionerv1connect" - "github.com/unkeyed/unkey/go/pkg/builder" "github.com/unkeyed/unkey/go/pkg/db" + "github.com/unkeyed/unkey/go/pkg/git" "github.com/unkeyed/unkey/go/pkg/hydra" "github.com/unkeyed/unkey/go/pkg/otel/logging" "github.com/unkeyed/unkey/go/pkg/uid" @@ -18,19 +18,17 @@ import ( // DeployWorkflow orchestrates the complete build and deployment process using Hydra type DeployWorkflow struct { - db db.Database - logger logging.Logger - builderService builder.Service - metaldClient vmprovisionerv1connect.VmServiceClient + db db.Database + logger logging.Logger + metaldClient vmprovisionerv1connect.VmServiceClient } // NewDeployWorkflow creates a new deploy workflow instance -func NewDeployWorkflow(database db.Database, logger logging.Logger, builderService builder.Service, metaldClient vmprovisionerv1connect.VmServiceClient) *DeployWorkflow { +func NewDeployWorkflow(database db.Database, logger logging.Logger, metaldClient vmprovisionerv1connect.VmServiceClient) *DeployWorkflow { return &DeployWorkflow{ - db: database, - logger: logger, - builderService: builderService, - metaldClient: metaldClient, + db: database, + logger: logger, + metaldClient: metaldClient, } } @@ -80,19 +78,41 @@ func (w *DeployWorkflow) Run(ctx hydra.WorkflowContext, req *DeployRequest) erro w.logger.Info("starting deployment workflow", "execution_id", ctx.ExecutionID(), "version_id", req.VersionID, - "docker_image", req.DockerImage) + "docker_image", req.DockerImage, + "workspace_id", req.WorkspaceID, + "project_id", req.ProjectID) // Step 1: Generate build ID buildID, err := hydra.Step(ctx, "generate-build-id", func(stepCtx context.Context) (string, error) { - return uid.New(uid.BuildPrefix), nil + id := uid.New(uid.BuildPrefix) + w.logger.Info("generated build ID", "build_id", id) + return id, nil }) if err != nil { w.logger.Error("failed to generate build ID", "error", err) return err } - // Step 4: Insert build into database - _, err = hydra.Step(ctx, "insert-build", func(stepCtx context.Context) (*struct{}, error) { + w.logger.Info("proceeding with build", "build_id", buildID) + + // Step 2: Log version pending + err = hydra.StepVoid(ctx, "log-version-pending", func(stepCtx context.Context) error { + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "pending", + Message: sql.NullString{String: "Version queued and ready to start", Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), + }) + }) + if err != nil { + w.logger.Error("failed to log version pending", "error", err, "version_id", req.VersionID) + return err + } + + // Step 3: Insert build into database + err = hydra.StepVoid(ctx, "insert-build", func(stepCtx context.Context) error { + w.logger.Info("inserting build into database", "build_id", buildID) insertErr := db.Query.InsertBuild(stepCtx, w.db.RW(), db.InsertBuildParams{ ID: buildID, WorkspaceID: req.WorkspaceID, @@ -101,17 +121,19 @@ func (w *DeployWorkflow) Run(ctx hydra.WorkflowContext, req *DeployRequest) erro CreatedAt: time.Now().UnixMilli(), }) if insertErr != nil { - return nil, fmt.Errorf("failed to create build record: %w", insertErr) + return fmt.Errorf("failed to create build record: %w", insertErr) } - return &struct{}{}, nil + w.logger.Info("build record created successfully", "build_id", buildID) + return nil }) if err != nil { w.logger.Error("failed to insert build", "error", err, "build_id", buildID) return err } - // Step 5: Update version status to building + // Step 4: Update version status to building _, err = hydra.Step(ctx, "update-version-building", func(stepCtx context.Context) (*struct{}, error) { + w.logger.Info("updating version status to building", "version_id", req.VersionID) updateErr := db.Query.UpdateVersionStatus(stepCtx, w.db.RW(), db.UpdateVersionStatusParams{ ID: req.VersionID, Status: db.VersionsStatusBuilding, @@ -120,6 +142,7 @@ func (w *DeployWorkflow) Run(ctx hydra.WorkflowContext, req *DeployRequest) erro if updateErr != nil { return nil, fmt.Errorf("failed to update version status to building: %w", updateErr) } + w.logger.Info("version status updated to building", "version_id", req.VersionID) return &struct{}{}, nil }) if err != nil { @@ -127,341 +150,423 @@ func (w *DeployWorkflow) Run(ctx hydra.WorkflowContext, req *DeployRequest) erro return err } - // Step 6: Submit build to builder service - _, err = hydra.Step(ctx, "submit-build", func(stepCtx context.Context) (*struct{}, error) { - w.logger.Info("submitting build to builder service", - "build_id", buildID, - "docker_image", req.DockerImage) - - submitErr := w.builderService.SubmitBuild(stepCtx, buildID, req.DockerImage) - if submitErr != nil { - return nil, fmt.Errorf("failed to submit build to builder service: %w", submitErr) + // Step 5: Update build status to running + _, err = hydra.Step(ctx, "update-build-running", func(stepCtx context.Context) (*struct{}, error) { + w.logger.Info("updating build status to running", "build_id", buildID) + now := time.Now().UnixMilli() + runningErr := db.Query.UpdateBuildStatus(stepCtx, w.db.RW(), db.UpdateBuildStatusParams{ + ID: buildID, + Status: db.BuildsStatusRunning, + Now: sql.NullInt64{Valid: true, Int64: now}, + }) + if runningErr != nil { + return nil, fmt.Errorf("failed to update build status to running: %w", runningErr) } - return &struct{}{}, nil }) if err != nil { - w.logger.Error("failed to submit build", "error", err, "build_id", buildID) + w.logger.Error("failed to update build status to running", "error", err, "build_id", buildID) return err } - // Wait for build completion with polling (max 150 attempts = 5 minutes) - var buildResult *BuildResult - lastStatus := "" - - for attempt := 1; attempt <= 150; attempt++ { - currentBuildStatus, err := hydra.Step(ctx, fmt.Sprintf("check-build-status-%d", attempt), func(stepCtx context.Context) (*builder.BuildInfo, error) { - buildStatus, statusErr := w.builderService.GetBuildStatus(stepCtx, buildID) - if statusErr != nil { - return nil, fmt.Errorf("failed to get build status: %w", statusErr) - } - - w.logger.Info("build status check", "build_id", buildID, "status", string(buildStatus.Status), "attempt", attempt) - return buildStatus, nil + // Step 6: Log downloading Docker image + err = hydra.StepVoid(ctx, "log-downloading-docker-image", func(stepCtx context.Context) error { + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "downloading_docker_image", + Message: sql.NullString{String: fmt.Sprintf("Downloading Docker image: %s", req.DockerImage), Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), }) - if err != nil { - w.logger.Error("failed to check build status", "error", err, "build_id", buildID, "attempt", attempt) - return err - } - - currentStatus := string(currentBuildStatus.Status) - - // Skip database update if status hasn't changed - if currentStatus == lastStatus { - // Status unchanged, continue to build completion check - } else { - _, err = hydra.Step(ctx, fmt.Sprintf("update-build-status-%d", attempt), func(updateCtx context.Context) (*struct{}, error) { - now := time.Now().UnixMilli() - - switch currentBuildStatus.Status { - case builder.BuildStatusQueued: - // Build is queued, no update needed yet - - case builder.BuildStatusRunning: - runningErr := db.Query.UpdateBuildStatus(updateCtx, w.db.RW(), db.UpdateBuildStatusParams{ - ID: buildID, - Status: db.BuildsStatusRunning, - Now: sql.NullInt64{Valid: true, Int64: now}, - }) - if runningErr != nil { - return nil, fmt.Errorf("failed to update build status to running: %w", runningErr) - } - - case builder.BuildStatusSuccess: - successErr := db.Query.UpdateBuildSucceeded(updateCtx, w.db.RW(), db.UpdateBuildSucceededParams{ - ID: buildID, - Now: sql.NullInt64{Valid: true, Int64: now}, - }) - if successErr != nil { - return nil, fmt.Errorf("failed to update build status to succeeded: %w", successErr) - } - - case builder.BuildStatusFailed: - failedErr := db.Query.UpdateBuildFailed(updateCtx, w.db.RW(), db.UpdateBuildFailedParams{ - ID: buildID, - ErrorMessage: sql.NullString{String: currentBuildStatus.ErrorMsg, Valid: currentBuildStatus.ErrorMsg != ""}, - Now: sql.NullInt64{Valid: true, Int64: now}, - }) - if failedErr != nil { - return nil, fmt.Errorf("failed to update build status to failed: %w", failedErr) - } - - // Also update version status to failed - versionErr := db.Query.UpdateVersionStatus(updateCtx, w.db.RW(), db.UpdateVersionStatusParams{ - ID: req.VersionID, - Status: db.VersionsStatusFailed, - Now: sql.NullInt64{Valid: true, Int64: now}, - }) - if versionErr != nil { - return nil, fmt.Errorf("failed to update version status to failed: %w", versionErr) - } - } + }) + if err != nil { + w.logger.Error("failed to log downloading Docker image", "error", err, "version_id", req.VersionID) + return err + } - return &struct{}{}, nil - }) - if err != nil { - w.logger.Error("failed to update build status", "error", err, "status", currentStatus, "attempt", attempt) - return err - } - lastStatus = currentStatus + // Step 7: Create VM (network call to metald) + createResult, err := hydra.Step(ctx, "metald-create-vm", func(stepCtx context.Context) (*vmprovisionerv1.CreateVmResponse, error) { + w.logger.Info("creating VM for deployment", "version_id", req.VersionID, "docker_image", req.DockerImage, "workspace_id", req.WorkspaceID, "project_id", req.ProjectID) + + // MOCK: VM configuration no longer needed since we're bypassing metald + // TODO: Remove this comment when real metald calls are restored + _ = &vmprovisionerv1.VmConfig{ + Cpu: &vmprovisionerv1.CpuConfig{ + VcpuCount: 2, + MaxVcpuCount: 4, + }, + Memory: &vmprovisionerv1.MemoryConfig{ + SizeBytes: 2 * 1024 * 1024 * 1024, // 2GB + MaxSizeBytes: 8 * 1024 * 1024 * 1024, // 8GB + HotplugEnabled: true, + }, + Boot: &vmprovisionerv1.BootConfig{ + KernelPath: "/opt/vm-assets/vmlinux", + KernelArgs: "console=ttyS0 reboot=k panic=1 pci=off", + }, + Storage: []*vmprovisionerv1.StorageDevice{{ + Id: "rootfs", + Path: "/opt/vm-assets/rootfs.ext4", + ReadOnly: false, + IsRootDevice: true, + InterfaceType: "virtio-blk", + Options: map[string]string{ + "docker_image": req.DockerImage, + "auto_build": "true", + }, + }}, + Network: []*vmprovisionerv1.NetworkInterface{{ + Id: "eth0", + InterfaceType: "virtio-net", + Mode: vmprovisionerv1.NetworkMode_NETWORK_MODE_DUAL_STACK, + Ipv4Config: &vmprovisionerv1.IPv4Config{ + Dhcp: true, + }, + Ipv6Config: &vmprovisionerv1.IPv6Config{ + Slaac: true, + PrivacyExtensions: true, + }, + }}, + Console: &vmprovisionerv1.ConsoleConfig{ + Enabled: true, + Output: "/tmp/standard-vm-console.log", + ConsoleType: "serial", + }, + Metadata: map[string]string{ + "template": "standard", + "purpose": "general", + "docker_image": req.DockerImage, + "runtime": "docker", + "version_id": req.VersionID, + "workspace_id": req.WorkspaceID, + "project_id": req.ProjectID, + "created_by": "deploy-workflow", + }, } - // Check if build is complete - switch currentBuildStatus.Status { - case builder.BuildStatusSuccess: - buildResult = &BuildResult{ - BuildID: buildID, - Status: "succeeded", - ErrorMsg: "", - } - goto buildComplete + // MOCK: Bypassing metald CreateVm call due to missing VM infrastructure + // TODO: Remove this mock and use real metald call once VM assets are available + w.logger.Info("MOCK: Simulating VM creation request", "docker_image", req.DockerImage) - case builder.BuildStatusFailed: - buildResult = &BuildResult{ - BuildID: buildID, - Status: "failed", - ErrorMsg: currentBuildStatus.ErrorMsg, - } - goto buildComplete - - default: - // Still building, sleep before next attempt - err = hydra.Sleep(ctx, 2*time.Second) - if err != nil { - w.logger.Error("failed to sleep between build checks", "error", err, "attempt", attempt) - return err - } + // Generate realistic mock VM ID and response + mockVMID := uid.New("vm") // Generate mock VM ID + resp := &vmprovisionerv1.CreateVmResponse{ + VmId: mockVMID, + State: vmprovisionerv1.VmState_VM_STATE_CREATED, } - } - // If we reach here, we exceeded max attempts - return fmt.Errorf("build polling timed out after 150 attempts (5 minutes)") + w.logger.Info("MOCK: VM creation simulated successfully", "vm_id", mockVMID, "docker_image", req.DockerImage) -buildComplete: + w.logger.Info("VM created successfully", "vm_id", resp.VmId, "state", resp.State.String(), "docker_image", req.DockerImage) - // Handle build failure - if buildResult.Status == "failed" { - w.logger.Error("build failed", "build_id", buildID, "error", buildResult.ErrorMsg) - return fmt.Errorf("build failed: %s", buildResult.ErrorMsg) + return resp, nil + }) + if err != nil { + w.logger.Error("VM creation failed", "error", err, "version_id", req.VersionID) + return err } - // Deploy if build succeeded - if buildResult.Status == "succeeded" { - - // Create VM first - createResult, err := hydra.Step(ctx, "create-vm", func(stepCtx context.Context) (*vmprovisionerv1.CreateVmResponse, error) { - w.logger.Info("creating VM for deployment", "version_id", req.VersionID, "docker_image", req.DockerImage) + w.logger.Info("VM creation completed", "vm_id", createResult.VmId, "state", createResult.State.String()) - // Hardcoded VM configuration (TemplateStandard + ForDockerImage): - vmConfig := &vmprovisionerv1.VmConfig{ - Cpu: &vmprovisionerv1.CpuConfig{ - VcpuCount: 2, - MaxVcpuCount: 4, - }, - Memory: &vmprovisionerv1.MemoryConfig{ - SizeBytes: 2 * 1024 * 1024 * 1024, // 2GB - MaxSizeBytes: 8 * 1024 * 1024 * 1024, // 8GB - HotplugEnabled: true, - }, - Boot: &vmprovisionerv1.BootConfig{ - KernelPath: "/opt/vm-assets/vmlinux", - KernelArgs: "console=ttyS0 reboot=k panic=1 pci=off", - }, - Storage: []*vmprovisionerv1.StorageDevice{{ - Id: "rootfs", - Path: "/opt/vm-assets/rootfs.ext4", - ReadOnly: false, - IsRootDevice: true, - InterfaceType: "virtio-blk", - Options: map[string]string{ - "docker_image": req.DockerImage, - "auto_build": "true", - }, - }}, - Network: []*vmprovisionerv1.NetworkInterface{{ - Id: "eth0", - InterfaceType: "virtio-net", - Mode: vmprovisionerv1.NetworkMode_NETWORK_MODE_DUAL_STACK, - Ipv4Config: &vmprovisionerv1.IPv4Config{ - Dhcp: true, - }, - Ipv6Config: &vmprovisionerv1.IPv6Config{ - Slaac: true, - PrivacyExtensions: true, - }, - }}, - Console: &vmprovisionerv1.ConsoleConfig{ - Enabled: true, - Output: "/tmp/standard-vm-console.log", - ConsoleType: "serial", - }, - Metadata: map[string]string{ - "template": "standard", - "purpose": "general", - "docker_image": req.DockerImage, - "runtime": "docker", - "version_id": req.VersionID, - "workspace_id": req.WorkspaceID, - "project_id": req.ProjectID, - "created_by": "deploy-workflow", - }, - } + // Step 8: Log building rootfs + err = hydra.StepVoid(ctx, "log-building-rootfs", func(stepCtx context.Context) error { + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "building_rootfs", + Message: sql.NullString{String: fmt.Sprintf("Building rootfs from Docker image: %s", req.DockerImage), Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), + }) + }) + if err != nil { + w.logger.Error("failed to log building rootfs", "error", err, "version_id", req.VersionID) + return err + } - resp, createErr := w.metaldClient.CreateVm(stepCtx, connect.NewRequest(&vmprovisionerv1.CreateVmRequest{ - Config: vmConfig, - })) - if createErr != nil { - return nil, fmt.Errorf("failed to create VM: %w", createErr) - } + // Step 9: Log uploading rootfs + err = hydra.StepVoid(ctx, "log-uploading-rootfs", func(stepCtx context.Context) error { + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "uploading_rootfs", + Message: sql.NullString{String: "Uploading rootfs image to storage", Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), + }) + }) + if err != nil { + w.logger.Error("failed to log uploading rootfs", "error", err, "version_id", req.VersionID) + return err + } - w.logger.Info("VM created successfully", "vm_id", resp.Msg.VmId, "state", resp.Msg.State.String()) - return resp.Msg, nil + // Step 10: Update build status to succeeded + _, err = hydra.Step(ctx, "update-build-succeeded", func(stepCtx context.Context) (*struct{}, error) { + w.logger.Info("updating build status to succeeded", "build_id", buildID) + successErr := db.Query.UpdateBuildSucceeded(stepCtx, w.db.RW(), db.UpdateBuildSucceededParams{ + ID: buildID, + Now: sql.NullInt64{Valid: true, Int64: time.Now().UnixMilli()}, }) - if err != nil { - w.logger.Error("VM creation failed", "error", err, "version_id", req.VersionID) - return err + if successErr != nil { + return nil, fmt.Errorf("failed to update build status to succeeded: %w", successErr) } + w.logger.Info("build status updated to succeeded", "build_id", buildID) + return &struct{}{}, nil + }) + if err != nil { + w.logger.Error("failed to update build status to succeeded", "error", err, "build_id", buildID) + return err + } - // Update version status to deploying (after successful VM creation) - _, err = hydra.Step(ctx, "update-version-deploying", func(stepCtx context.Context) (*struct{}, error) { - w.logger.Info("starting deployment", "version_id", req.VersionID) - - deployingErr := db.Query.UpdateVersionStatus(stepCtx, w.db.RW(), db.UpdateVersionStatusParams{ - ID: req.VersionID, - Status: db.VersionsStatusDeploying, - Now: sql.NullInt64{Valid: true, Int64: time.Now().UnixMilli()}, - }) - if deployingErr != nil { - return nil, fmt.Errorf("failed to update version status to deploying: %w", deployingErr) - } - return &struct{}{}, nil + // Step 11: Log creating VM + err = hydra.StepVoid(ctx, "log-creating-vm", func(stepCtx context.Context) error { + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "creating_vm", + Message: sql.NullString{String: fmt.Sprintf("Creating VM for version: %s", req.VersionID), Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), + }) + }) + if err != nil { + w.logger.Error("failed to log creating VM", "error", err, "version_id", req.VersionID) + return err + } + + // Step 12: Update version status to deploying + _, err = hydra.Step(ctx, "update-version-deploying", func(stepCtx context.Context) (*struct{}, error) { + w.logger.Info("starting deployment", "version_id", req.VersionID) + + deployingErr := db.Query.UpdateVersionStatus(stepCtx, w.db.RW(), db.UpdateVersionStatusParams{ + ID: req.VersionID, + Status: db.VersionsStatusDeploying, + Now: sql.NullInt64{Valid: true, Int64: time.Now().UnixMilli()}, }) - if err != nil { - w.logger.Error("failed to update version status to deploying", "error", err, "version_id", req.VersionID) - return err + if deployingErr != nil { + return nil, fmt.Errorf("failed to update version status to deploying: %w", deployingErr) } + return &struct{}{}, nil + }) + if err != nil { + w.logger.Error("failed to update version status to deploying", "error", err, "version_id", req.VersionID) + return err + } + + // Step 13: Poll VM status (network calls to metald) + w.logger.Info("starting VM status polling", "vm_id", createResult.VmId, "max_attempts", 30) - // Check VM readiness (max 30 attempts = 30 seconds) + _, err = hydra.Step(ctx, "metald-poll-vm-status", func(stepCtx context.Context) (*struct{}, error) { for attempt := 1; attempt <= 30; attempt++ { - vmInfo, err := hydra.Step(ctx, fmt.Sprintf("check-vm-status-%d", attempt), func(stepCtx context.Context) (*vmprovisionerv1.GetVmInfoResponse, error) { - resp, getErr := w.metaldClient.GetVmInfo(stepCtx, connect.NewRequest(&vmprovisionerv1.GetVmInfoRequest{ - VmId: createResult.VmId, - })) - if getErr != nil { - return nil, fmt.Errorf("failed to get VM info: %w", getErr) - } - - w.logger.Info("VM status check", "vm_id", createResult.VmId, "state", resp.Msg.State.String(), "attempt", attempt) - return resp.Msg, nil - }) - if err != nil { - w.logger.Error("failed to check VM status", "error", err, "vm_id", createResult.VmId, "attempt", attempt) - return err + w.logger.Info("checking VM status", "vm_id", createResult.VmId, "attempt", attempt) + + // MOCK: Bypassing metald GetVmInfo call - simulating realistic VM preparation + // TODO: Remove this mock and use real metald call once VM assets are available + w.logger.Info("MOCK: Simulating VM status request", "vm_id", createResult.VmId, "attempt", attempt) + + // Simulate realistic VM preparation progression + var mockState vmprovisionerv1.VmState + if attempt <= 2 { + mockState = vmprovisionerv1.VmState_VM_STATE_UNSPECIFIED // Use UNSPECIFIED to simulate building state + w.logger.Info("MOCK: VM still building", "vm_id", createResult.VmId, "attempt", attempt) + } else { + mockState = vmprovisionerv1.VmState_VM_STATE_CREATED + w.logger.Info("MOCK: VM preparation complete", "vm_id", createResult.VmId, "attempt", attempt) + } + + resp := &vmprovisionerv1.GetVmInfoResponse{ + VmId: createResult.VmId, + State: mockState, } + w.logger.Info("VM status check", "vm_id", createResult.VmId, "state", resp.State.String(), "attempt", attempt) + // Check if VM is ready for boot - if vmInfo.State == vmprovisionerv1.VmState_VM_STATE_CREATED || - vmInfo.State == vmprovisionerv1.VmState_VM_STATE_RUNNING { - w.logger.Info("VM is ready", "vm_id", createResult.VmId, "state", vmInfo.State.String()) - goto vmReady + if resp.State == vmprovisionerv1.VmState_VM_STATE_CREATED || + resp.State == vmprovisionerv1.VmState_VM_STATE_RUNNING { + w.logger.Info("VM is ready", "vm_id", createResult.VmId, "state", resp.State.String()) + return &struct{}{}, nil } // Sleep before next attempt (except on last attempt) if attempt < 30 { - err = hydra.Sleep(ctx, 1*time.Second) - if err != nil { - w.logger.Error("failed to sleep between VM checks", "error", err, "attempt", attempt) - return err - } + w.logger.Info("VM not ready yet, sleeping before next check", "vm_id", createResult.VmId, "state", resp.State.String(), "attempt", attempt, "sleep_duration", "1s") + time.Sleep(1 * time.Second) } } - // If we reach here, VM never became ready - return fmt.Errorf("VM polling timed out after 30 attempts (30 seconds)") + // If we reach here, we exceeded max attempts + return nil, fmt.Errorf("VM polling timed out after 30 attempts (30 seconds)") + }) + if err != nil { + w.logger.Error("VM status polling failed", "error", err, "vm_id", createResult.VmId) + return err + } -vmReady: + // Step 14: Boot VM (network call to metald) + _, err = hydra.Step(ctx, "metald-boot-vm", func(stepCtx context.Context) (*vmprovisionerv1.BootVmResponse, error) { + w.logger.Info("booting VM", "vm_id", createResult.VmId) - // Boot VM - _, err = hydra.Step(ctx, "boot-vm", func(stepCtx context.Context) (*vmprovisionerv1.BootVmResponse, error) { - w.logger.Info("booting VM", "vm_id", createResult.VmId) + // MOCK: Bypassing metald BootVm call - simulating successful boot + // TODO: Remove this mock and use real metald call once VM assets are available + w.logger.Info("MOCK: Simulating VM boot request", "vm_id", createResult.VmId) - resp, bootErr := w.metaldClient.BootVm(stepCtx, connect.NewRequest(&vmprovisionerv1.BootVmRequest{ - VmId: createResult.VmId, - })) - if bootErr != nil { - return nil, fmt.Errorf("failed to boot VM: %w", bootErr) - } + // Simulate successful VM boot + resp := &vmprovisionerv1.BootVmResponse{ + Success: true, + State: vmprovisionerv1.VmState_VM_STATE_RUNNING, + } - if !resp.Msg.Success { - return nil, fmt.Errorf("VM boot was not successful, state: %s", resp.Msg.State.String()) - } + w.logger.Info("MOCK: VM boot simulated successfully", "vm_id", createResult.VmId) + + if !resp.Success { + w.logger.Error("VM boot was not successful", "vm_id", createResult.VmId, "state", resp.State.String()) + return nil, fmt.Errorf("VM boot was not successful, state: %s", resp.State.String()) + } + + w.logger.Info("VM booted successfully", "vm_id", createResult.VmId, "state", resp.State.String()) + return resp, nil + }) + if err != nil { + w.logger.Error("VM boot failed", "error", err, "vm_id", createResult.VmId) + return err + } + + w.logger.Info("VM boot completed successfully", "vm_id", createResult.VmId) - w.logger.Info("VM booted successfully", "vm_id", createResult.VmId, "state", resp.Msg.State.String()) - return resp.Msg, nil + // Step 16: Log booting VM + err = hydra.StepVoid(ctx, "log-booting-vm", func(stepCtx context.Context) error { + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "booting_vm", + Message: sql.NullString{String: fmt.Sprintf("VM booted successfully: %s", createResult.VmId), Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), }) - if err != nil { - w.logger.Error("VM boot failed", "error", err, "vm_id", createResult.VmId) - return err + }) + if err != nil { + w.logger.Error("failed to log booting VM", "error", err, "version_id", req.VersionID) + return err + } + + // Step 17: Assign domains (create route entries) + assignedHostnames, err := hydra.Step(ctx, "assign-domains", func(stepCtx context.Context) ([]string, error) { + w.logger.Info("assigning domains to version", "version_id", req.VersionID) + + // Generate hostnames for this deployment + // Use Git info for hostname generation + gitInfo := git.GetInfo() + branch := "main" // Default branch + identifier := req.VersionID // Use full version ID as identifier + + if gitInfo.IsRepo { + if gitInfo.Branch != "" { + branch = gitInfo.Branch + } + if gitInfo.CommitSHA != "" { + identifier = gitInfo.CommitSHA + } } - // Generate completion timestamp - completionTime, err := hydra.Step(ctx, "generate-completion-timestamp", func(stepCtx context.Context) (int64, error) { - return time.Now().UnixMilli(), nil + // Generate hostnames: branch-identifier-workspace.unkey.app + // Replace underscores with dashes for valid hostname format + cleanIdentifier := strings.ReplaceAll(identifier, "_", "-") + hostname := fmt.Sprintf("%s-%s-%s.unkey.app", branch, cleanIdentifier, req.WorkspaceID) + + // Create route entry + routeID := uid.New("route") + insertErr := db.Query.InsertRoute(stepCtx, w.db.RW(), db.InsertRouteParams{ + ID: routeID, + WorkspaceID: req.WorkspaceID, + ProjectID: req.ProjectID, + Hostname: hostname, + VersionID: req.VersionID, + IsEnabled: true, + CreatedAt: time.Now().UnixMilli(), + UpdatedAt: sql.NullInt64{Valid: true, Int64: time.Now().UnixMilli()}, }) - if err != nil { - w.logger.Error("failed to generate completion timestamp", "error", err) - return err + if insertErr != nil { + w.logger.Error("failed to create route", "error", insertErr, "hostname", hostname, "version_id", req.VersionID) + return nil, fmt.Errorf("failed to create route for hostname %s: %w", hostname, insertErr) } - // Update version status to active - _, err = hydra.Step(ctx, "update-version-active", func(stepCtx context.Context) (*DeploymentResult, error) { - activeErr := db.Query.UpdateVersionStatus(stepCtx, w.db.RW(), db.UpdateVersionStatusParams{ - ID: req.VersionID, - Status: db.VersionsStatusActive, - Now: sql.NullInt64{Valid: true, Int64: completionTime}, - }) - if activeErr != nil { - return nil, fmt.Errorf("failed to update version status to active: %w", activeErr) - } + w.logger.Info("domain assigned successfully", "hostname", hostname, "version_id", req.VersionID, "route_id", routeID) + return []string{hostname}, nil + }) + if err != nil { + w.logger.Error("domain assignment failed", "error", err, "version_id", req.VersionID) + return err + } - w.logger.Info("deployment complete", "version_id", req.VersionID) + // Step 18: Log assigning domains + err = hydra.StepVoid(ctx, "log-assigning-domains", func(stepCtx context.Context) error { + var message string + if len(assignedHostnames) > 0 { + message = fmt.Sprintf("Assigned hostname: %s", assignedHostnames[0]) + } else { + message = "Domain assignment completed" + } + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "assigning_domains", + Message: sql.NullString{String: message, Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), + }) + }) + if err != nil { + w.logger.Error("failed to log assigning domains", "error", err, "version_id", req.VersionID) + return err + } - return &DeploymentResult{ - VersionID: req.VersionID, - Status: "active", - }, nil + // Step 19: Update version status to active + _, err = hydra.Step(ctx, "update-version-active", func(stepCtx context.Context) (*DeploymentResult, error) { + completionTime := time.Now().UnixMilli() + w.logger.Info("updating version status to active", "version_id", req.VersionID, "completion_time", completionTime) + activeErr := db.Query.UpdateVersionStatus(stepCtx, w.db.RW(), db.UpdateVersionStatusParams{ + ID: req.VersionID, + Status: db.VersionsStatusActive, + Now: sql.NullInt64{Valid: true, Int64: completionTime}, }) - if err != nil { - w.logger.Error("deployment failed", "error", err, "version_id", req.VersionID) - return err + if activeErr != nil { + w.logger.Error("failed to update version status to active", "error", activeErr, "version_id", req.VersionID) + return nil, fmt.Errorf("failed to update version status to active: %w", activeErr) } + + w.logger.Info("deployment complete", "version_id", req.VersionID, "status", "active") + + return &DeploymentResult{ + VersionID: req.VersionID, + Status: "active", + }, nil + }) + if err != nil { + w.logger.Error("deployment failed", "error", err, "version_id", req.VersionID) + return err } + // Step 20: Log completed + err = hydra.StepVoid(ctx, "log-completed", func(stepCtx context.Context) error { + return db.Query.InsertVersionStep(stepCtx, w.db.RW(), db.InsertVersionStepParams{ + VersionID: req.VersionID, + Status: "completed", + Message: sql.NullString{String: "Version deployment completed successfully", Valid: true}, + ErrorMessage: sql.NullString{}, + CreatedAt: time.Now().UnixMilli(), + }) + }) + if err != nil { + w.logger.Error("failed to log completed", "error", err, "version_id", req.VersionID) + return err + } + + w.logger.Info("deployment workflow stage completed successfully", "version_id", req.VersionID, "vm_id", createResult.VmId) + w.logger.Info("deployment workflow completed", "execution_id", ctx.ExecutionID(), "build_id", buildID, "version_id", req.VersionID, - "status", buildResult.Status) + "status", "succeeded", + "workspace_id", req.WorkspaceID, + "project_id", req.ProjectID, + "docker_image", req.DockerImage) return nil } diff --git a/go/apps/ctrl/services/version/get_version.go b/go/apps/ctrl/services/version/get_version.go index a689890257..24b75c14ed 100644 --- a/go/apps/ctrl/services/version/get_version.go +++ b/go/apps/ctrl/services/version/get_version.go @@ -2,12 +2,10 @@ package version import ( "context" - "time" "connectrpc.com/connect" ctrlv1 "github.com/unkeyed/unkey/go/gen/proto/ctrl/v1" "github.com/unkeyed/unkey/go/pkg/db" - "google.golang.org/protobuf/types/known/timestamppb" ) func (s *Service) GetVersion( @@ -27,16 +25,17 @@ func (s *Service) GetVersion( ProjectId: version.ProjectID, EnvironmentId: "", // No longer in schema Status: convertDbStatusToProto(string(version.Status)), - CreatedAt: timestamppb.New(time.UnixMilli(version.CreatedAt)), + CreatedAt: version.CreatedAt, GitCommitSha: "", GitBranch: "", ErrorMessage: "", EnvironmentVariables: nil, Topology: nil, - UpdatedAt: nil, + UpdatedAt: 0, Hostnames: nil, RootfsImageId: "", BuildId: "", + Steps: nil, } if version.GitCommitSha.Valid { @@ -46,7 +45,7 @@ func (s *Service) GetVersion( protoVersion.GitBranch = version.GitBranch.String } if version.UpdatedAt.Valid { - protoVersion.UpdatedAt = timestamppb.New(time.UnixMilli(version.UpdatedAt.Int64)) + protoVersion.UpdatedAt = version.UpdatedAt.Int64 } if version.RootfsImageID != "" { protoVersion.RootfsImageId = version.RootfsImageID @@ -58,6 +57,41 @@ func (s *Service) GetVersion( protoVersion.BuildId = build.ID } + // Fetch version steps + versionSteps, err := db.Query.FindVersionStepsByVersionId(ctx, s.db.RO(), version.ID) + if err != nil { + s.logger.Warn("failed to fetch version steps", "error", err, "version_id", version.ID) + // Continue without steps rather than failing the entire request + } else { + protoSteps := make([]*ctrlv1.VersionStep, len(versionSteps)) + for i, step := range versionSteps { + protoSteps[i] = &ctrlv1.VersionStep{ + Status: string(step.Status), + CreatedAt: step.CreatedAt, + } + if step.Message.Valid { + protoSteps[i].Message = step.Message.String + } + if step.ErrorMessage.Valid { + protoSteps[i].ErrorMessage = step.ErrorMessage.String + } + } + protoVersion.Steps = protoSteps + } + + // Fetch routes (hostnames) for this version + routes, err := db.Query.FindRoutesByVersionId(ctx, s.db.RO(), version.ID) + if err != nil { + s.logger.Warn("failed to fetch routes for version", "error", err, "version_id", version.ID) + // Continue without hostnames rather than failing the entire request + } else { + hostnames := make([]string, len(routes)) + for i, route := range routes { + hostnames[i] = route.Hostname + } + protoVersion.Hostnames = hostnames + } + res := connect.NewResponse(&ctrlv1.GetVersionResponse{ Version: protoVersion, }) diff --git a/go/apps/ctrl/services/version/service.go b/go/apps/ctrl/services/version/service.go index 0452de6201..937e45384a 100644 --- a/go/apps/ctrl/services/version/service.go +++ b/go/apps/ctrl/services/version/service.go @@ -2,7 +2,6 @@ package version import ( "github.com/unkeyed/unkey/go/gen/proto/ctrl/v1/ctrlv1connect" - "github.com/unkeyed/unkey/go/pkg/builder" "github.com/unkeyed/unkey/go/pkg/db" "github.com/unkeyed/unkey/go/pkg/hydra" "github.com/unkeyed/unkey/go/pkg/otel/logging" @@ -10,18 +9,16 @@ import ( type Service struct { ctrlv1connect.UnimplementedVersionServiceHandler - db db.Database - hydraEngine *hydra.Engine - builderService builder.Service - logger logging.Logger + db db.Database + hydraEngine *hydra.Engine + logger logging.Logger } -func New(database db.Database, hydraEngine *hydra.Engine, builderService builder.Service, logger logging.Logger) *Service { +func New(database db.Database, hydraEngine *hydra.Engine, logger logging.Logger) *Service { return &Service{ UnimplementedVersionServiceHandler: ctrlv1connect.UnimplementedVersionServiceHandler{}, db: database, hydraEngine: hydraEngine, - builderService: builderService, logger: logger, } } diff --git a/go/cmd/ctrl/main.go b/go/cmd/ctrl/main.go index 02fa163a9f..0c379e5a1c 100644 --- a/go/cmd/ctrl/main.go +++ b/go/cmd/ctrl/main.go @@ -112,6 +112,19 @@ var Cmd = &cli.Command{ Sources: cli.EnvVars("UNKEY_AUTH_TOKEN"), Required: false, }, + &cli.StringFlag{ + Name: "metald-address", + Usage: "Full URL of the metald service for VM operations. Required for deployments. Example: https://metald.example.com:8080", + Sources: cli.EnvVars("UNKEY_METALD_ADDRESS"), + Required: true, + }, + &cli.StringFlag{ + Name: "spiffe-socket-path", + Usage: "Path to SPIFFE agent socket for mTLS authentication. Default: /var/lib/spire/agent/agent.sock", + Sources: cli.EnvVars("UNKEY_SPIFFE_SOCKET_PATH"), + Value: "/var/lib/spire/agent/agent.sock", + Required: false, + }, }, Action: action, @@ -155,7 +168,9 @@ func action(ctx context.Context, cmd *cli.Command) error { TLSConfig: tlsConfig, // Control Plane Specific - AuthToken: cmd.String("auth-token"), + AuthToken: cmd.String("auth-token"), + MetaldAddress: cmd.String("metald-address"), + SPIFFESocketPath: cmd.String("spiffe-socket-path"), // Common Clock: clock.New(), diff --git a/go/cmd/version/main.go b/go/cmd/version/main.go index e471754413..0d57985a19 100644 --- a/go/cmd/version/main.go +++ b/go/cmd/version/main.go @@ -7,14 +7,12 @@ import ( "fmt" "io" "log/slog" - "math/rand" "net/http" "os/exec" "strings" "time" "connectrpc.com/connect" - "github.com/charmbracelet/lipgloss" ctrlv1 "github.com/unkeyed/unkey/go/gen/proto/ctrl/v1" "github.com/unkeyed/unkey/go/gen/proto/ctrl/v1/ctrlv1connect" "github.com/unkeyed/unkey/go/pkg/codes" @@ -128,87 +126,46 @@ func createAction(ctx context.Context, cmd *cli.Command) error { return runDeploymentSteps(ctx, cmd, workspace, project, branch, dockerImage, dockerfile, buildContext, commit, logger) } -// Styles for clean output -var ( - sectionName = lipgloss.NewStyle().Bold(true) - metaText = lipgloss.NewStyle().Foreground(lipgloss.Color("8")) - errorText = lipgloss.NewStyle().Foreground(lipgloss.Color("9")) -) - -// Fun loading messages for different deployment phases -var ( - buildingMessages = []string{ - "Transforming containers into pure magic...", - "Teaching Docker images to fly...", - "Compressing pixels and dreams...", - "Turning containers inside out...", - "Extracting the essence of your code...", - "Squishing containers flat like pancakes...", - "Converting Docker to VM-speak...", - } - - deployingMessages = []string{ - "Waking up sleepy virtual machines...", - "Teaching VMs to dance with your code...", - "Summoning compute spirits from the cloud...", - "Bribing CPUs with electricity...", - "Convincing VMs to get out of bed...", - "Herding virtual cats into formation...", - "Rolling out the red carpet for your app...", - } - - buildQueuedMessages = []string{ - "Waiting in line behind the other builds...", - "Taking a number at the build deli...", - "Patience, young padawan...", - "Good things come to those who wait...", - "Counting sheep until build starts...", - "Build is doing pre-flight checks...", +func printDeploymentComplete(versionID, workspace, branch, commit string) { + // Use actual Git info for hostname generation + gitInfo := git.GetInfo() + identifier := versionID + if gitInfo.IsRepo && gitInfo.CommitSHA != "" { + identifier = gitInfo.CommitSHA } -) -func printDeploymentComplete(versionID, workspace, branch, commit string) { fmt.Println() - fmt.Printf("%s\n", sectionName.Render("Deployment Complete")) - fmt.Printf(" Version ID: %s\n", metaText.Render(versionID)) + fmt.Println("Deployment Complete") + fmt.Printf(" Version ID: %s\n", versionID) fmt.Printf(" Status: Ready\n") fmt.Printf(" Environment: Production\n") fmt.Println() - fmt.Printf("%s\n", sectionName.Render("Domains")) + fmt.Println("Domains") + // Replace underscores with dashes for valid hostname format + cleanIdentifier := strings.ReplaceAll(identifier, "_", "-") + fmt.Printf(" https://%s-%s-%s.unkey.app\n", branch, cleanIdentifier, workspace) + fmt.Printf(" https://api.acme.com\n") +} - // Use actual Git info for hostname generation - gitInfo := git.GetInfo() - shortSHA := "unknown" - if gitInfo.ShortSHA != "" { - shortSHA = gitInfo.ShortSHA - } else if commit != "" && len(commit) >= 7 { - shortSHA = commit[:7] - } +func runDeploymentSteps(ctx context.Context, cmd *cli.Command, workspace, project, branch, dockerImage, dockerfile, buildContext, commit string, logger logging.Logger) error { - fmt.Printf(" %s\n", metaText.Render(fmt.Sprintf("https://%s-%s-%s.unkey.app", branch, shortSHA, workspace))) - fmt.Printf(" %s\n", metaText.Render("https://api.acme.com")) + // Get Git info for better image tagging + gitInfo := git.GetInfo() - fmt.Println() - fmt.Printf("%s\n", sectionName.Render("Source")) + // Print source information immediately + fmt.Println("Source") fmt.Printf(" Branch: %s\n", branch) - if gitInfo.ShortSHA != "" { - fmt.Printf(" Commit: %s\n", gitInfo.ShortSHA) + if gitInfo.CommitSHA != "" { + fmt.Printf(" Commit: %s\n", gitInfo.CommitSHA) if gitInfo.IsDirty { - fmt.Printf(" Status: %s\n", metaText.Render("Working directory has uncommitted changes")) + fmt.Printf(" Status: Working directory has uncommitted changes\n") } } -} - -func runDeploymentSteps(ctx context.Context, cmd *cli.Command, workspace, project, branch, dockerImage, dockerfile, buildContext, commit string, logger logging.Logger) error { - - // Get Git info for better image tagging - gitInfo := git.GetInfo() + fmt.Println() // If no docker image provided, build one if dockerImage == "" { - fmt.Printf("%s\n", sectionName.Render("Building")) - // Generate image tag using Git info when available var imageTag string if gitInfo.ShortSHA != "" { @@ -220,11 +177,7 @@ func runDeploymentSteps(ctx context.Context, cmd *cli.Command, workspace, projec } dockerImage = fmt.Sprintf("ghcr.io/unkeyed/deploy-wip:%s", imageTag) - fmt.Printf(" Image tag: %s\n", metaText.Render(dockerImage)) - fmt.Printf(" Build context: %s\n", metaText.Render(buildContext)) - - // Docker build steps - fmt.Printf(" Building Docker image...\n") + fmt.Printf("Building Docker image %s...\n", dockerImage) // Build the Docker image with minimal output var buildArgs []string @@ -271,25 +224,24 @@ func runDeploymentSteps(ctx context.Context, cmd *cli.Command, workspace, projec allOutput.WriteString(line + "\n") // Print all docker build output - fmt.Printf(" %s\n", metaText.Render(line)) + fmt.Printf(" %s\n", line) } // Wait for the build to complete err = buildCmd.Wait() if err != nil { - fmt.Printf(" %s: Docker build failed\n", errorText.Render("Error")) + fmt.Printf("Docker build failed\n") // Show the full build output on failure for _, line := range strings.Split(allOutput.String(), "\n") { if strings.TrimSpace(line) != "" { - fmt.Printf(" %s\n", line) + fmt.Printf(" %s\n", line) } } return fmt.Errorf("docker build failed: %w", err) } - // Publishing section - fmt.Printf("%s\n", sectionName.Render("Publishing")) + fmt.Printf("Publishing Docker image...\n") pushCmd := exec.CommandContext(ctx, "docker", "push", dockerImage) @@ -300,20 +252,17 @@ func runDeploymentSteps(ctx context.Context, cmd *cli.Command, workspace, projec // Run the push if err := pushCmd.Run(); err != nil { - fmt.Printf(" %s: Docker push failed\n", errorText.Render("Error")) + fmt.Printf("Docker push failed\n") // Show the push output on failure for _, line := range strings.Split(pushOutput.String(), "\n") { if strings.TrimSpace(line) != "" { - fmt.Printf(" %s\n", line) + fmt.Printf(" %s\n", line) } } return fmt.Errorf("docker push failed: %w", err) } } - // Creating Version section - fmt.Printf("%s\n", sectionName.Render("Creating Version")) - // Create control plane client controlPlaneURL := cmd.String("control-plane-url") authToken := cmd.String("auth-token") @@ -369,9 +318,8 @@ func runDeploymentSteps(ctx context.Context, cmd *cli.Command, workspace, projec } versionID := createResp.Msg.GetVersionId() - fmt.Printf(" Version ID: %s\n", metaText.Render(versionID)) - fmt.Printf(" Image: %s\n", metaText.Render(dockerImage)) - fmt.Printf(" Branch: %s\n", metaText.Render(branch)) + fmt.Printf("Creating Version\n") + fmt.Printf(" Version ID: %s\n", versionID) // Poll for version status updates if err := pollVersionStatus(ctx, logger, client, versionID); err != nil { @@ -383,22 +331,22 @@ func runDeploymentSteps(ctx context.Context, cmd *cli.Command, workspace, projec return nil } -// pollVersionStatus polls the control plane API for version status updates +// pollVersionStatus polls the control plane API and displays deployment steps as they occur func pollVersionStatus(ctx context.Context, logger logging.Logger, client ctrlv1connect.VersionServiceClient, versionID string) error { ticker := time.NewTicker(2 * time.Second) defer ticker.Stop() - timeout := time.NewTimer(30 * time.Second) // 30 second timeout + timeout := time.NewTimer(300 * time.Second) // 5 minute timeout for full deployment defer timeout.Stop() - lastVersionStatus := "" + displayedSteps := make(map[string]bool) for { select { case <-ctx.Done(): return ctx.Err() case <-timeout.C: - fmt.Printf("Error: Deployment timeout after 30 seconds\n") + fmt.Printf("Error: Deployment timeout after 5 minutes\n") return fmt.Errorf("deployment timeout") case <-ticker.C: // Always poll version status @@ -414,33 +362,15 @@ func pollVersionStatus(ctx context.Context, logger logging.Logger, client ctrlv1 } version := getResp.Msg.GetVersion() - currentVersionStatus := version.GetStatus().String() - - // Show version status updates with section headers - if currentVersionStatus != lastVersionStatus { - switch version.GetStatus() { - case ctrlv1.VersionStatus_VERSION_STATUS_UNSPECIFIED: - // Skip unspecified status, no display needed - case ctrlv1.VersionStatus_VERSION_STATUS_PENDING: - fmt.Printf("%s\n", sectionName.Render("Pending")) - message := buildQueuedMessages[rand.Intn(len(buildQueuedMessages))] // nolint:gosec // Weak random is acceptable for UI messages - fmt.Printf(" %s\n", metaText.Render(message)) - case ctrlv1.VersionStatus_VERSION_STATUS_BUILDING: - fmt.Printf("%s\n", sectionName.Render("Building")) - message := buildingMessages[rand.Intn(len(buildingMessages))] // nolint:gosec // Weak random is acceptable for UI messages - fmt.Printf(" %s\n", metaText.Render(message)) - case ctrlv1.VersionStatus_VERSION_STATUS_DEPLOYING: - fmt.Printf("%s\n", sectionName.Render("Deploying")) - message := deployingMessages[rand.Intn(len(deployingMessages))] // nolint:gosec // Weak random is acceptable for UI messages - fmt.Printf(" %s\n", metaText.Render(message)) - case ctrlv1.VersionStatus_VERSION_STATUS_ACTIVE: - // Will be handled after the polling loop - case ctrlv1.VersionStatus_VERSION_STATUS_FAILED: - fmt.Printf(" %s: Deployment failed\n", errorText.Render("Error")) - case ctrlv1.VersionStatus_VERSION_STATUS_ARCHIVED: - fmt.Printf(" %s: Version archived\n", metaText.Render("Info")) + + // Display version steps in real-time + steps := version.GetSteps() + for _, step := range steps { + stepKey := step.GetStatus() + if !displayedSteps[stepKey] { + displayVersionStep(step) + displayedSteps[stepKey] = true } - lastVersionStatus = currentVersionStatus } // Check if deployment is complete @@ -456,6 +386,21 @@ func pollVersionStatus(ctx context.Context, logger logging.Logger, client ctrlv1 } } +// displayVersionStep shows a version step with appropriate formatting +func displayVersionStep(step *ctrlv1.VersionStep) { + message := step.GetMessage() + + // Display only the actual message from the database, indented under "Creating Version" + if message != "" { + fmt.Printf(" %s\n", message) + } + + // Show error message if present + if step.GetErrorMessage() != "" { + fmt.Printf(" Error: %s\n", step.GetErrorMessage()) + } +} + var getCmd = &cli.Command{ Name: "get", Usage: "Get details about a version", diff --git a/go/deploy/ctrl/Makefile b/go/deploy/ctrl/Makefile new file mode 100644 index 0000000000..1565ce7d33 --- /dev/null +++ b/go/deploy/ctrl/Makefile @@ -0,0 +1,108 @@ +# Ctrl Control Plane Service - Docker Makefile + +.DEFAULT_GOAL := help + +# Variables +SERVICE_NAME := ctrl +IMAGE_NAME := unkey/$(SERVICE_NAME) +TRUST_DOMAIN := development.unkey.app +SPIRE_SOCKET := /var/lib/spire/server/server.sock +SPIRE_DIR := /opt/spire + +# Colors for output +GREEN := \033[0;32m +YELLOW := \033[1;33m +RED := \033[0;31m +BLUE := \033[0;34m +CYAN := \033[36m +NC := \033[0m +RESET := \033[0m + +.PHONY: help build run stop logs spire-register clean compose-up compose-down + +help: ## Display this help message + @echo "" + @echo "$(CYAN)Ctrl Control Plane Service - Docker Management$(RESET)" + @echo "" + @awk 'BEGIN {FS = ":.*##"; printf "Usage:\n make $(CYAN)$(RESET)\n"} /^[a-zA-Z_-]+:.*?##/ { printf " $(CYAN)%-20s$(RESET) %s\n", $$1, $$2 }' $(MAKEFILE_LIST) + @echo "" + +build: ## Build Docker image + @echo "$(BLUE)Building Docker image...$(NC)" + @docker build -t $(IMAGE_NAME):latest --build-arg VERSION=latest ../../ + @echo "$(GREEN)✓ Image built: $(IMAGE_NAME):latest$(NC)" + +run: ## Run Docker container + @echo "$(BLUE)Starting ctrl container...$(NC)" + @docker run -d --name unkey-$(SERVICE_NAME) \ + -p 8084:8084 \ + -v /var/lib/spire/agent/agent.sock:/var/lib/spire/agent/agent.sock \ + -e UNKEY_DATABASE_PRIMARY="$${UNKEY_DATABASE_PRIMARY}" \ + -e UNKEY_DATABASE_HYDRA="$${UNKEY_DATABASE_HYDRA}" \ + -e UNKEY_METALD_ADDRESS="$${UNKEY_METALD_ADDRESS:-https://host.docker.internal:8080}" \ + -e UNKEY_HTTP_PORT="8084" \ + -e UNKEY_PLATFORM="docker" \ + -e UNKEY_REGION="docker" \ + -e UNKEY_OTEL="true" \ + -e UNKEY_SPIFFE_SOCKET_PATH="/var/lib/spire/agent/agent.sock" \ + $(IMAGE_NAME):latest run ctrl + @echo "$(GREEN)✓ Container started: unkey-$(SERVICE_NAME)$(NC)" + @echo "$(YELLOW)Next: Run 'make spire-register' to register with SPIRE$(NC)" + +stop: ## Stop and remove Docker container + @echo "$(BLUE)Stopping ctrl container...$(NC)" + @docker stop unkey-$(SERVICE_NAME) 2>/dev/null || true + @docker rm unkey-$(SERVICE_NAME) 2>/dev/null || true + @echo "$(GREEN)✓ Container stopped$(NC)" + +logs: ## Follow container logs + @docker logs -f unkey-$(SERVICE_NAME) + +spire-register: ## Register Docker container with SPIRE (stable selectors) + @echo "$(BLUE)Registering ctrl container with SPIRE...$(NC)" + @echo "Trust Domain: $(YELLOW)$(TRUST_DOMAIN)$(NC)" + @if [ ! -S "$(SPIRE_SOCKET)" ]; then \ + echo "$(RED)Error: SPIRE server socket not available at $(SPIRE_SOCKET)$(NC)"; \ + exit 1; \ + fi + @PARENT_ID="spiffe://$(TRUST_DOMAIN)/agent/node1"; \ + SPIFFE_ID="spiffe://$(TRUST_DOMAIN)/service/$(SERVICE_NAME)"; \ + echo "$(BLUE)Cleaning up any existing registrations...$(NC)"; \ + sudo $(SPIRE_DIR)/bin/spire-server entry show -socketPath "$(SPIRE_SOCKET)" -spiffeID "$$SPIFFE_ID" 2>/dev/null | grep "Entry ID" | awk '{print $$4}' | while read entry_id; do \ + if [ ! -z "$$entry_id" ]; then \ + echo "$(YELLOW)Deleting existing entry: $$entry_id$(NC)"; \ + sudo $(SPIRE_DIR)/bin/spire-server entry delete -socketPath "$(SPIRE_SOCKET)" -entryID "$$entry_id" 2>/dev/null || true; \ + fi; \ + done; \ + echo "$(BLUE)Creating new stable registration...$(NC)"; \ + sudo $(SPIRE_DIR)/bin/spire-server entry create \ + -socketPath "$(SPIRE_SOCKET)" \ + -parentID "$$PARENT_ID" \ + -spiffeID "$$SPIFFE_ID" \ + -selector "docker:label:com.docker.compose.service:$(SERVICE_NAME)" \ + -x509SVIDTTL 3600 \ + && echo "$(GREEN)✓ $(SERVICE_NAME) registered with SPIRE using stable selectors$(NC)" \ + || (echo "$(RED)✗ Failed to register $(SERVICE_NAME)$(NC)" && exit 1) + +clean: ## Remove Docker image + @echo "$(BLUE)Cleaning up...$(NC)" + @docker rmi $(IMAGE_NAME):latest 2>/dev/null || true + @echo "$(GREEN)✓ Cleanup complete$(NC)" + +# Combined targets +up: build run spire-register ## Build, run, and register with SPIRE + @echo "$(GREEN)✓ Ctrl service is up and running!$(NC)" + +down: stop ## Stop container + @echo "$(GREEN)✓ Ctrl service stopped$(NC)" + +compose-up: ## Build and start with docker-compose + @echo "$(BLUE)Building and starting with docker-compose...$(NC)" + @docker compose up -d --build + @echo "$(GREEN)✓ Container built and started with docker-compose$(NC)" + @echo "$(YELLOW)Next: Run 'make spire-register' to register with SPIRE$(NC)" + +compose-down: ## Stop docker-compose + @echo "$(BLUE)Stopping docker-compose...$(NC)" + @docker compose down + @echo "$(GREEN)✓ Docker-compose stopped$(NC)" diff --git a/go/deploy/ctrl/docker-compose.yml b/go/deploy/ctrl/docker-compose.yml new file mode 100644 index 0000000000..ceb4a42825 --- /dev/null +++ b/go/deploy/ctrl/docker-compose.yml @@ -0,0 +1,68 @@ +version: '3.8' + +services: + mysql: + container_name: ctrl-mysql + build: + context: ../../../ + dockerfile: deployment/Dockerfile.mysql + restart: always + environment: + MYSQL_ROOT_PASSWORD: root + MYSQL_DATABASE: unkey + MYSQL_USER: unkey + MYSQL_PASSWORD: password + command: ["--max_connections=1000"] + ports: + - 3306:3306 + volumes: + - mysql:/var/lib/mysql + - ../../../deployment/init-databases.sql:/docker-entrypoint-initdb.d/init-databases.sql + + ctrl: + build: + context: ../../ + dockerfile: Dockerfile + args: + VERSION: "latest" + container_name: unkey-ctrl + ports: + - "8084:8084" + depends_on: + - mysql + extra_hosts: + - "host.docker.internal:host-gateway" + environment: + # Database configuration + UNKEY_DATABASE_PRIMARY: ${UNKEY_DATABASE_PRIMARY} + UNKEY_DATABASE_HYDRA: "unkey:password@tcp(mysql:3306)/hydra?parseTime=true" + + # Control plane configuration + UNKEY_HTTP_PORT: "8084" + UNKEY_METALD_ADDRESS: ${UNKEY_METALD_ADDRESS:-https://host.docker.internal:8080} + + # Instance configuration + UNKEY_PLATFORM: "docker" + UNKEY_REGION: "docker" + UNKEY_OTEL: "true" + UNKEY_SPIFFE_SOCKET_PATH: "/var/lib/spire/agent/agent.sock" + + volumes: + # Mount SPIFFE agent socket from host + - /var/lib/spire/agent/agent.sock:/var/lib/spire/agent/agent.sock + + restart: unless-stopped + + # Override the entrypoint to run ctrl command + command: ["run", "ctrl"] + + # Health check + healthcheck: + test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8084/_/health"] + interval: 30s + timeout: 5s + retries: 3 + start_period: 10s + +volumes: + mysql: \ No newline at end of file diff --git a/go/deploy/metald/client/cmd/metald-cli/main.go b/go/deploy/metald/client/cmd/metald-cli/main.go index ebb2e5c4ba..0fccb27f18 100644 --- a/go/deploy/metald/client/cmd/metald-cli/main.go +++ b/go/deploy/metald/client/cmd/metald-cli/main.go @@ -562,7 +562,7 @@ func handleCreateAndBoot(ctx context.Context, metaldClient *client.Client, optio VMID: vmID, Config: config, } - + log.Printf("createReq: %+v/n", createReq) createResp, err := metaldClient.CreateVM(ctx, createReq) if err != nil { log.Fatalf("Failed to create VM: %v", err) diff --git a/go/deploy/metald/client/go.mod b/go/deploy/metald/client/go.mod index 89ecf4d9ec..36a2120332 100644 --- a/go/deploy/metald/client/go.mod +++ b/go/deploy/metald/client/go.mod @@ -4,7 +4,7 @@ go 1.24.4 require ( connectrpc.com/connect v1.18.1 - github.com/unkeyed/unkey/go/deploy/metald v0.0.0 + github.com/unkeyed/unkey/go v0.0.0-00010101000000-000000000000 github.com/unkeyed/unkey/go/deploy/pkg/tls v0.0.0 ) @@ -28,3 +28,5 @@ replace github.com/unkeyed/unkey/go/deploy/metald => .. replace github.com/unkeyed/unkey/go/deploy/pkg/tls => ../../pkg/tls replace github.com/unkeyed/unkey/go/deploy/pkg/spiffe => ../../pkg/spiffe + +replace github.com/unkeyed/unkey/go => ../../.. diff --git a/go/deploy/metald/client/go.sum b/go/deploy/metald/client/go.sum index b646af454b..665693e8b6 100644 --- a/go/deploy/metald/client/go.sum +++ b/go/deploy/metald/client/go.sum @@ -2,8 +2,8 @@ connectrpc.com/connect v1.18.1 h1:PAg7CjSAGvscaf6YZKUefjoih5Z/qYkyaTrBW8xvYPw= connectrpc.com/connect v1.18.1/go.mod h1:0292hj1rnx8oFrStN7cB4jjVBeqs+Yx5yDIC2prWDO8= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-jose/go-jose/v4 v4.0.5 h1:M6T8+mKZl/+fNNuFHvGIzDz7BTLQPIounk/b9dw3AaE= github.com/go-jose/go-jose/v4 v4.0.5/go.mod h1:s3P1lRrkT8igV8D9OjyL4WRyHvjB6a4JSllnOrmmBOA= github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= @@ -16,8 +16,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/spiffe/go-spiffe/v2 v2.5.0 h1:N2I01KCUkv1FAjZXJMwh95KK1ZIQLYbPfhaxw8WS0hE= github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= diff --git a/go/deploy/metald/client/metald-cli b/go/deploy/metald/client/metald-cli new file mode 100755 index 0000000000..9cd59413cd Binary files /dev/null and b/go/deploy/metald/client/metald-cli differ diff --git a/go/deploy/metald/internal/service/vm.go b/go/deploy/metald/internal/service/vm.go index af29ae6035..f3317ae10d 100644 --- a/go/deploy/metald/internal/service/vm.go +++ b/go/deploy/metald/internal/service/vm.go @@ -2,6 +2,7 @@ package service import ( "context" + "encoding/json" "fmt" "log/slog" "math" @@ -65,6 +66,14 @@ func (s *VMService) CreateVm(ctx context.Context, req *connect.Request[metaldv1. } config := req.Msg.GetConfig() + + // DEBUG: Log full request config for debugging + if config != nil { + configJSON, _ := json.Marshal(config) + s.logger.LogAttrs(ctx, slog.LevelInfo, "DEBUG: Full VM config received", + slog.String("config_json", string(configJSON)), + ) + } if config == nil { err := fmt.Errorf("vm config is required") span.RecordError(err) diff --git a/go/deploy/spire/environments/development/agent.conf b/go/deploy/spire/environments/development/agent.conf index 1d3e68e6b6..b5c3f19712 100644 --- a/go/deploy/spire/environments/development/agent.conf +++ b/go/deploy/spire/environments/development/agent.conf @@ -45,6 +45,14 @@ plugins { discover_workload_group = true } } + + # Docker workload attestor for container-based identity + WorkloadAttestor "docker" { + plugin_data { + # Docker socket for container inspection + docker_socket_path = "unix:///var/run/docker.sock" + } + } } health_checks { diff --git a/go/gen/deploy/metald/proto/vmprovisioner/v1/vm.pb.go b/go/gen/deploy/metald/proto/vmprovisioner/v1/vm.pb.go deleted file mode 100644 index 0c366e9041..0000000000 --- a/go/gen/deploy/metald/proto/vmprovisioner/v1/vm.pb.go +++ /dev/null @@ -1,2864 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// versions: -// protoc-gen-go v1.36.6 -// protoc (unknown) -// source: deploy/metald/proto/vmprovisioner/v1/vm.proto - -package vmprovisionerv1 - -import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" - reflect "reflect" - sync "sync" - unsafe "unsafe" -) - -const ( - // Verify that this generated code is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) - // Verify that runtime/protoimpl is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) -) - -// VM lifecycle states -type VmState int32 - -const ( - VmState_VM_STATE_UNSPECIFIED VmState = 0 - VmState_VM_STATE_CREATED VmState = 1 - VmState_VM_STATE_RUNNING VmState = 2 - VmState_VM_STATE_PAUSED VmState = 3 - VmState_VM_STATE_SHUTDOWN VmState = 4 -) - -// Enum value maps for VmState. -var ( - VmState_name = map[int32]string{ - 0: "VM_STATE_UNSPECIFIED", - 1: "VM_STATE_CREATED", - 2: "VM_STATE_RUNNING", - 3: "VM_STATE_PAUSED", - 4: "VM_STATE_SHUTDOWN", - } - VmState_value = map[string]int32{ - "VM_STATE_UNSPECIFIED": 0, - "VM_STATE_CREATED": 1, - "VM_STATE_RUNNING": 2, - "VM_STATE_PAUSED": 3, - "VM_STATE_SHUTDOWN": 4, - } -) - -func (x VmState) Enum() *VmState { - p := new(VmState) - *p = x - return p -} - -func (x VmState) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (VmState) Descriptor() protoreflect.EnumDescriptor { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_enumTypes[0].Descriptor() -} - -func (VmState) Type() protoreflect.EnumType { - return &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_enumTypes[0] -} - -func (x VmState) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use VmState.Descriptor instead. -func (VmState) EnumDescriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{0} -} - -// Network mode for the interface -type NetworkMode int32 - -const ( - NetworkMode_NETWORK_MODE_UNSPECIFIED NetworkMode = 0 - NetworkMode_NETWORK_MODE_DUAL_STACK NetworkMode = 1 // Both IPv4 and IPv6 - NetworkMode_NETWORK_MODE_IPV4_ONLY NetworkMode = 2 // IPv4 only - NetworkMode_NETWORK_MODE_IPV6_ONLY NetworkMode = 3 // IPv6 only -) - -// Enum value maps for NetworkMode. -var ( - NetworkMode_name = map[int32]string{ - 0: "NETWORK_MODE_UNSPECIFIED", - 1: "NETWORK_MODE_DUAL_STACK", - 2: "NETWORK_MODE_IPV4_ONLY", - 3: "NETWORK_MODE_IPV6_ONLY", - } - NetworkMode_value = map[string]int32{ - "NETWORK_MODE_UNSPECIFIED": 0, - "NETWORK_MODE_DUAL_STACK": 1, - "NETWORK_MODE_IPV4_ONLY": 2, - "NETWORK_MODE_IPV6_ONLY": 3, - } -) - -func (x NetworkMode) Enum() *NetworkMode { - p := new(NetworkMode) - *p = x - return p -} - -func (x NetworkMode) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (NetworkMode) Descriptor() protoreflect.EnumDescriptor { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_enumTypes[1].Descriptor() -} - -func (NetworkMode) Type() protoreflect.EnumType { - return &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_enumTypes[1] -} - -func (x NetworkMode) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use NetworkMode.Descriptor instead. -func (NetworkMode) EnumDescriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{1} -} - -// Unified VM configuration that works across different hypervisors -type VmConfig struct { - state protoimpl.MessageState `protogen:"open.v1"` - // CPU configuration - Cpu *CpuConfig `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty"` - // Memory configuration - Memory *MemoryConfig `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty"` - // Boot configuration - Boot *BootConfig `protobuf:"bytes,3,opt,name=boot,proto3" json:"boot,omitempty"` - // Storage devices - Storage []*StorageDevice `protobuf:"bytes,4,rep,name=storage,proto3" json:"storage,omitempty"` - // Network interfaces - Network []*NetworkInterface `protobuf:"bytes,5,rep,name=network,proto3" json:"network,omitempty"` - // Console configuration - Console *ConsoleConfig `protobuf:"bytes,6,opt,name=console,proto3" json:"console,omitempty"` - // Metadata and labels - Metadata map[string]string `protobuf:"bytes,7,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *VmConfig) Reset() { - *x = VmConfig{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *VmConfig) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*VmConfig) ProtoMessage() {} - -func (x *VmConfig) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[0] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use VmConfig.ProtoReflect.Descriptor instead. -func (*VmConfig) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{0} -} - -func (x *VmConfig) GetCpu() *CpuConfig { - if x != nil { - return x.Cpu - } - return nil -} - -func (x *VmConfig) GetMemory() *MemoryConfig { - if x != nil { - return x.Memory - } - return nil -} - -func (x *VmConfig) GetBoot() *BootConfig { - if x != nil { - return x.Boot - } - return nil -} - -func (x *VmConfig) GetStorage() []*StorageDevice { - if x != nil { - return x.Storage - } - return nil -} - -func (x *VmConfig) GetNetwork() []*NetworkInterface { - if x != nil { - return x.Network - } - return nil -} - -func (x *VmConfig) GetConsole() *ConsoleConfig { - if x != nil { - return x.Console - } - return nil -} - -func (x *VmConfig) GetMetadata() map[string]string { - if x != nil { - return x.Metadata - } - return nil -} - -type CpuConfig struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Number of virtual CPUs to allocate at boot - VcpuCount int32 `protobuf:"varint,1,opt,name=vcpu_count,json=vcpuCount,proto3" json:"vcpu_count,omitempty"` - // Maximum number of virtual CPUs (for hotplug) - MaxVcpuCount int32 `protobuf:"varint,2,opt,name=max_vcpu_count,json=maxVcpuCount,proto3" json:"max_vcpu_count,omitempty"` - // CPU topology (optional) - Topology *CpuTopology `protobuf:"bytes,3,opt,name=topology,proto3" json:"topology,omitempty"` - // CPU features and model (backend-specific) - Features map[string]string `protobuf:"bytes,4,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *CpuConfig) Reset() { - *x = CpuConfig{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *CpuConfig) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CpuConfig) ProtoMessage() {} - -func (x *CpuConfig) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[1] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use CpuConfig.ProtoReflect.Descriptor instead. -func (*CpuConfig) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{1} -} - -func (x *CpuConfig) GetVcpuCount() int32 { - if x != nil { - return x.VcpuCount - } - return 0 -} - -func (x *CpuConfig) GetMaxVcpuCount() int32 { - if x != nil { - return x.MaxVcpuCount - } - return 0 -} - -func (x *CpuConfig) GetTopology() *CpuTopology { - if x != nil { - return x.Topology - } - return nil -} - -func (x *CpuConfig) GetFeatures() map[string]string { - if x != nil { - return x.Features - } - return nil -} - -type CpuTopology struct { - state protoimpl.MessageState `protogen:"open.v1"` - Sockets int32 `protobuf:"varint,1,opt,name=sockets,proto3" json:"sockets,omitempty"` - CoresPerSocket int32 `protobuf:"varint,2,opt,name=cores_per_socket,json=coresPerSocket,proto3" json:"cores_per_socket,omitempty"` - ThreadsPerCore int32 `protobuf:"varint,3,opt,name=threads_per_core,json=threadsPerCore,proto3" json:"threads_per_core,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *CpuTopology) Reset() { - *x = CpuTopology{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *CpuTopology) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CpuTopology) ProtoMessage() {} - -func (x *CpuTopology) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[2] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use CpuTopology.ProtoReflect.Descriptor instead. -func (*CpuTopology) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{2} -} - -func (x *CpuTopology) GetSockets() int32 { - if x != nil { - return x.Sockets - } - return 0 -} - -func (x *CpuTopology) GetCoresPerSocket() int32 { - if x != nil { - return x.CoresPerSocket - } - return 0 -} - -func (x *CpuTopology) GetThreadsPerCore() int32 { - if x != nil { - return x.ThreadsPerCore - } - return 0 -} - -type MemoryConfig struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Memory size in bytes - SizeBytes int64 `protobuf:"varint,1,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"` - // Whether memory hotplug is enabled - HotplugEnabled bool `protobuf:"varint,2,opt,name=hotplug_enabled,json=hotplugEnabled,proto3" json:"hotplug_enabled,omitempty"` - // Maximum memory size for hotplug (bytes) - MaxSizeBytes int64 `protobuf:"varint,3,opt,name=max_size_bytes,json=maxSizeBytes,proto3" json:"max_size_bytes,omitempty"` - // Memory backing options (hugepages, etc.) - Backing map[string]string `protobuf:"bytes,4,rep,name=backing,proto3" json:"backing,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *MemoryConfig) Reset() { - *x = MemoryConfig{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *MemoryConfig) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*MemoryConfig) ProtoMessage() {} - -func (x *MemoryConfig) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[3] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use MemoryConfig.ProtoReflect.Descriptor instead. -func (*MemoryConfig) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{3} -} - -func (x *MemoryConfig) GetSizeBytes() int64 { - if x != nil { - return x.SizeBytes - } - return 0 -} - -func (x *MemoryConfig) GetHotplugEnabled() bool { - if x != nil { - return x.HotplugEnabled - } - return false -} - -func (x *MemoryConfig) GetMaxSizeBytes() int64 { - if x != nil { - return x.MaxSizeBytes - } - return 0 -} - -func (x *MemoryConfig) GetBacking() map[string]string { - if x != nil { - return x.Backing - } - return nil -} - -type BootConfig struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Path to kernel image - KernelPath string `protobuf:"bytes,1,opt,name=kernel_path,json=kernelPath,proto3" json:"kernel_path,omitempty"` - // Path to initial ramdisk (optional) - InitrdPath string `protobuf:"bytes,2,opt,name=initrd_path,json=initrdPath,proto3" json:"initrd_path,omitempty"` - // Kernel command line arguments - KernelArgs string `protobuf:"bytes,3,opt,name=kernel_args,json=kernelArgs,proto3" json:"kernel_args,omitempty"` - // Boot order and options - BootOptions map[string]string `protobuf:"bytes,4,rep,name=boot_options,json=bootOptions,proto3" json:"boot_options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *BootConfig) Reset() { - *x = BootConfig{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *BootConfig) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*BootConfig) ProtoMessage() {} - -func (x *BootConfig) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[4] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use BootConfig.ProtoReflect.Descriptor instead. -func (*BootConfig) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{4} -} - -func (x *BootConfig) GetKernelPath() string { - if x != nil { - return x.KernelPath - } - return "" -} - -func (x *BootConfig) GetInitrdPath() string { - if x != nil { - return x.InitrdPath - } - return "" -} - -func (x *BootConfig) GetKernelArgs() string { - if x != nil { - return x.KernelArgs - } - return "" -} - -func (x *BootConfig) GetBootOptions() map[string]string { - if x != nil { - return x.BootOptions - } - return nil -} - -type StorageDevice struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Unique identifier for this storage device - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // Path to the backing file or block device - Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` - // Whether this device is read-only - ReadOnly bool `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"` - // Whether this is the root/boot device - IsRootDevice bool `protobuf:"varint,4,opt,name=is_root_device,json=isRootDevice,proto3" json:"is_root_device,omitempty"` - // Storage interface type (virtio-blk, nvme, etc.) - InterfaceType string `protobuf:"bytes,5,opt,name=interface_type,json=interfaceType,proto3" json:"interface_type,omitempty"` - // Additional storage options - Options map[string]string `protobuf:"bytes,6,rep,name=options,proto3" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *StorageDevice) Reset() { - *x = StorageDevice{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *StorageDevice) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*StorageDevice) ProtoMessage() {} - -func (x *StorageDevice) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[5] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use StorageDevice.ProtoReflect.Descriptor instead. -func (*StorageDevice) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{5} -} - -func (x *StorageDevice) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *StorageDevice) GetPath() string { - if x != nil { - return x.Path - } - return "" -} - -func (x *StorageDevice) GetReadOnly() bool { - if x != nil { - return x.ReadOnly - } - return false -} - -func (x *StorageDevice) GetIsRootDevice() bool { - if x != nil { - return x.IsRootDevice - } - return false -} - -func (x *StorageDevice) GetInterfaceType() string { - if x != nil { - return x.InterfaceType - } - return "" -} - -func (x *StorageDevice) GetOptions() map[string]string { - if x != nil { - return x.Options - } - return nil -} - -type NetworkInterface struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Unique identifier for this network interface - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // MAC address (optional, will be generated if not provided) - MacAddress string `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"` - // Host-side TAP device name - TapDevice string `protobuf:"bytes,3,opt,name=tap_device,json=tapDevice,proto3" json:"tap_device,omitempty"` - // Network interface type (virtio-net, e1000, etc.) - InterfaceType string `protobuf:"bytes,4,opt,name=interface_type,json=interfaceType,proto3" json:"interface_type,omitempty"` - // Additional network options - Options map[string]string `protobuf:"bytes,5,rep,name=options,proto3" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // IPv4 configuration (optional) - Ipv4Config *IPv4Config `protobuf:"bytes,6,opt,name=ipv4_config,json=ipv4Config,proto3" json:"ipv4_config,omitempty"` - // IPv6 configuration (optional) - Ipv6Config *IPv6Config `protobuf:"bytes,7,opt,name=ipv6_config,json=ipv6Config,proto3" json:"ipv6_config,omitempty"` - // Network mode - Mode NetworkMode `protobuf:"varint,8,opt,name=mode,proto3,enum=vmprovisioner.v1.NetworkMode" json:"mode,omitempty"` - // Rate limiting - RxRateLimit *RateLimit `protobuf:"bytes,10,opt,name=rx_rate_limit,json=rxRateLimit,proto3" json:"rx_rate_limit,omitempty"` // Receive rate limit - TxRateLimit *RateLimit `protobuf:"bytes,11,opt,name=tx_rate_limit,json=txRateLimit,proto3" json:"tx_rate_limit,omitempty"` // Transmit rate limit - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *NetworkInterface) Reset() { - *x = NetworkInterface{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *NetworkInterface) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*NetworkInterface) ProtoMessage() {} - -func (x *NetworkInterface) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[6] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use NetworkInterface.ProtoReflect.Descriptor instead. -func (*NetworkInterface) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{6} -} - -func (x *NetworkInterface) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *NetworkInterface) GetMacAddress() string { - if x != nil { - return x.MacAddress - } - return "" -} - -func (x *NetworkInterface) GetTapDevice() string { - if x != nil { - return x.TapDevice - } - return "" -} - -func (x *NetworkInterface) GetInterfaceType() string { - if x != nil { - return x.InterfaceType - } - return "" -} - -func (x *NetworkInterface) GetOptions() map[string]string { - if x != nil { - return x.Options - } - return nil -} - -func (x *NetworkInterface) GetIpv4Config() *IPv4Config { - if x != nil { - return x.Ipv4Config - } - return nil -} - -func (x *NetworkInterface) GetIpv6Config() *IPv6Config { - if x != nil { - return x.Ipv6Config - } - return nil -} - -func (x *NetworkInterface) GetMode() NetworkMode { - if x != nil { - return x.Mode - } - return NetworkMode_NETWORK_MODE_UNSPECIFIED -} - -func (x *NetworkInterface) GetRxRateLimit() *RateLimit { - if x != nil { - return x.RxRateLimit - } - return nil -} - -func (x *NetworkInterface) GetTxRateLimit() *RateLimit { - if x != nil { - return x.TxRateLimit - } - return nil -} - -// IPv4 network configuration -type IPv4Config struct { - state protoimpl.MessageState `protogen:"open.v1"` - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` // IPv4 address (e.g., "10.100.1.2") - Netmask string `protobuf:"bytes,2,opt,name=netmask,proto3" json:"netmask,omitempty"` // Network mask (e.g., "255.255.255.0") - Gateway string `protobuf:"bytes,3,opt,name=gateway,proto3" json:"gateway,omitempty"` // Default gateway - DnsServers []string `protobuf:"bytes,4,rep,name=dns_servers,json=dnsServers,proto3" json:"dns_servers,omitempty"` // DNS servers - Dhcp bool `protobuf:"varint,5,opt,name=dhcp,proto3" json:"dhcp,omitempty"` // Use DHCP instead of static config - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *IPv4Config) Reset() { - *x = IPv4Config{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *IPv4Config) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*IPv4Config) ProtoMessage() {} - -func (x *IPv4Config) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[7] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use IPv4Config.ProtoReflect.Descriptor instead. -func (*IPv4Config) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{7} -} - -func (x *IPv4Config) GetAddress() string { - if x != nil { - return x.Address - } - return "" -} - -func (x *IPv4Config) GetNetmask() string { - if x != nil { - return x.Netmask - } - return "" -} - -func (x *IPv4Config) GetGateway() string { - if x != nil { - return x.Gateway - } - return "" -} - -func (x *IPv4Config) GetDnsServers() []string { - if x != nil { - return x.DnsServers - } - return nil -} - -func (x *IPv4Config) GetDhcp() bool { - if x != nil { - return x.Dhcp - } - return false -} - -// IPv6 network configuration -type IPv6Config struct { - state protoimpl.MessageState `protogen:"open.v1"` - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` // IPv6 address (e.g., "fd00::1:2") - PrefixLength int32 `protobuf:"varint,2,opt,name=prefix_length,json=prefixLength,proto3" json:"prefix_length,omitempty"` // Prefix length (e.g., 64) - Gateway string `protobuf:"bytes,3,opt,name=gateway,proto3" json:"gateway,omitempty"` // Default gateway - DnsServers []string `protobuf:"bytes,4,rep,name=dns_servers,json=dnsServers,proto3" json:"dns_servers,omitempty"` // DNS servers (IPv6 addresses) - Slaac bool `protobuf:"varint,5,opt,name=slaac,proto3" json:"slaac,omitempty"` // Use SLAAC (Stateless Address Autoconfiguration) - PrivacyExtensions bool `protobuf:"varint,6,opt,name=privacy_extensions,json=privacyExtensions,proto3" json:"privacy_extensions,omitempty"` // Enable privacy extensions - LinkLocal string `protobuf:"bytes,7,opt,name=link_local,json=linkLocal,proto3" json:"link_local,omitempty"` // Link-local address (auto-generated if empty) - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *IPv6Config) Reset() { - *x = IPv6Config{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *IPv6Config) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*IPv6Config) ProtoMessage() {} - -func (x *IPv6Config) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[8] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use IPv6Config.ProtoReflect.Descriptor instead. -func (*IPv6Config) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{8} -} - -func (x *IPv6Config) GetAddress() string { - if x != nil { - return x.Address - } - return "" -} - -func (x *IPv6Config) GetPrefixLength() int32 { - if x != nil { - return x.PrefixLength - } - return 0 -} - -func (x *IPv6Config) GetGateway() string { - if x != nil { - return x.Gateway - } - return "" -} - -func (x *IPv6Config) GetDnsServers() []string { - if x != nil { - return x.DnsServers - } - return nil -} - -func (x *IPv6Config) GetSlaac() bool { - if x != nil { - return x.Slaac - } - return false -} - -func (x *IPv6Config) GetPrivacyExtensions() bool { - if x != nil { - return x.PrivacyExtensions - } - return false -} - -func (x *IPv6Config) GetLinkLocal() string { - if x != nil { - return x.LinkLocal - } - return "" -} - -// Rate limiting configuration -type RateLimit struct { - state protoimpl.MessageState `protogen:"open.v1"` - Bandwidth int64 `protobuf:"varint,1,opt,name=bandwidth,proto3" json:"bandwidth,omitempty"` // Bandwidth in bytes/second - RefillTime int64 `protobuf:"varint,2,opt,name=refill_time,json=refillTime,proto3" json:"refill_time,omitempty"` // Token bucket refill time in milliseconds - Burst int64 `protobuf:"varint,3,opt,name=burst,proto3" json:"burst,omitempty"` // Burst size in bytes - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *RateLimit) Reset() { - *x = RateLimit{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *RateLimit) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*RateLimit) ProtoMessage() {} - -func (x *RateLimit) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[9] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use RateLimit.ProtoReflect.Descriptor instead. -func (*RateLimit) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{9} -} - -func (x *RateLimit) GetBandwidth() int64 { - if x != nil { - return x.Bandwidth - } - return 0 -} - -func (x *RateLimit) GetRefillTime() int64 { - if x != nil { - return x.RefillTime - } - return 0 -} - -func (x *RateLimit) GetBurst() int64 { - if x != nil { - return x.Burst - } - return 0 -} - -type ConsoleConfig struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Whether console is enabled - Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` - // Console output destination (file path, pty, etc.) - Output string `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"` - // Console input source (optional) - Input string `protobuf:"bytes,3,opt,name=input,proto3" json:"input,omitempty"` - // Console type (serial, virtio-console, etc.) - ConsoleType string `protobuf:"bytes,4,opt,name=console_type,json=consoleType,proto3" json:"console_type,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ConsoleConfig) Reset() { - *x = ConsoleConfig{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ConsoleConfig) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ConsoleConfig) ProtoMessage() {} - -func (x *ConsoleConfig) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[10] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ConsoleConfig.ProtoReflect.Descriptor instead. -func (*ConsoleConfig) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{10} -} - -func (x *ConsoleConfig) GetEnabled() bool { - if x != nil { - return x.Enabled - } - return false -} - -func (x *ConsoleConfig) GetOutput() string { - if x != nil { - return x.Output - } - return "" -} - -func (x *ConsoleConfig) GetInput() string { - if x != nil { - return x.Input - } - return "" -} - -func (x *ConsoleConfig) GetConsoleType() string { - if x != nil { - return x.ConsoleType - } - return "" -} - -// Request/Response messages -type CreateVmRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Unique identifier for the VM (optional, will be generated if not provided) - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - // VM configuration - Config *VmConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"` - // Customer identifier for billing and isolation - CustomerId string `protobuf:"bytes,3,opt,name=customer_id,json=customerId,proto3" json:"customer_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *CreateVmRequest) Reset() { - *x = CreateVmRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *CreateVmRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CreateVmRequest) ProtoMessage() {} - -func (x *CreateVmRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[11] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use CreateVmRequest.ProtoReflect.Descriptor instead. -func (*CreateVmRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{11} -} - -func (x *CreateVmRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -func (x *CreateVmRequest) GetConfig() *VmConfig { - if x != nil { - return x.Config - } - return nil -} - -func (x *CreateVmRequest) GetCustomerId() string { - if x != nil { - return x.CustomerId - } - return "" -} - -type CreateVmResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Assigned VM identifier - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - // Current VM state after creation - State VmState `protobuf:"varint,2,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *CreateVmResponse) Reset() { - *x = CreateVmResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *CreateVmResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CreateVmResponse) ProtoMessage() {} - -func (x *CreateVmResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[12] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use CreateVmResponse.ProtoReflect.Descriptor instead. -func (*CreateVmResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{12} -} - -func (x *CreateVmResponse) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -func (x *CreateVmResponse) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -type DeleteVmRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - // Whether to force deletion even if VM is running - Force bool `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *DeleteVmRequest) Reset() { - *x = DeleteVmRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *DeleteVmRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteVmRequest) ProtoMessage() {} - -func (x *DeleteVmRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[13] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use DeleteVmRequest.ProtoReflect.Descriptor instead. -func (*DeleteVmRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{13} -} - -func (x *DeleteVmRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -func (x *DeleteVmRequest) GetForce() bool { - if x != nil { - return x.Force - } - return false -} - -type DeleteVmResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *DeleteVmResponse) Reset() { - *x = DeleteVmResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *DeleteVmResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteVmResponse) ProtoMessage() {} - -func (x *DeleteVmResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[14] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use DeleteVmResponse.ProtoReflect.Descriptor instead. -func (*DeleteVmResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{14} -} - -func (x *DeleteVmResponse) GetSuccess() bool { - if x != nil { - return x.Success - } - return false -} - -type BootVmRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *BootVmRequest) Reset() { - *x = BootVmRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *BootVmRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*BootVmRequest) ProtoMessage() {} - -func (x *BootVmRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[15] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use BootVmRequest.ProtoReflect.Descriptor instead. -func (*BootVmRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{15} -} - -func (x *BootVmRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -type BootVmResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - State VmState `protobuf:"varint,2,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *BootVmResponse) Reset() { - *x = BootVmResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *BootVmResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*BootVmResponse) ProtoMessage() {} - -func (x *BootVmResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[16] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use BootVmResponse.ProtoReflect.Descriptor instead. -func (*BootVmResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{16} -} - -func (x *BootVmResponse) GetSuccess() bool { - if x != nil { - return x.Success - } - return false -} - -func (x *BootVmResponse) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -type ShutdownVmRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - // Whether to force shutdown (vs graceful) - Force bool `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"` - // Timeout for graceful shutdown (seconds) - TimeoutSeconds int32 `protobuf:"varint,3,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ShutdownVmRequest) Reset() { - *x = ShutdownVmRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ShutdownVmRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ShutdownVmRequest) ProtoMessage() {} - -func (x *ShutdownVmRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[17] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ShutdownVmRequest.ProtoReflect.Descriptor instead. -func (*ShutdownVmRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{17} -} - -func (x *ShutdownVmRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -func (x *ShutdownVmRequest) GetForce() bool { - if x != nil { - return x.Force - } - return false -} - -func (x *ShutdownVmRequest) GetTimeoutSeconds() int32 { - if x != nil { - return x.TimeoutSeconds - } - return 0 -} - -type ShutdownVmResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - State VmState `protobuf:"varint,2,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ShutdownVmResponse) Reset() { - *x = ShutdownVmResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ShutdownVmResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ShutdownVmResponse) ProtoMessage() {} - -func (x *ShutdownVmResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[18] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ShutdownVmResponse.ProtoReflect.Descriptor instead. -func (*ShutdownVmResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{18} -} - -func (x *ShutdownVmResponse) GetSuccess() bool { - if x != nil { - return x.Success - } - return false -} - -func (x *ShutdownVmResponse) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -type PauseVmRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *PauseVmRequest) Reset() { - *x = PauseVmRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[19] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *PauseVmRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*PauseVmRequest) ProtoMessage() {} - -func (x *PauseVmRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[19] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use PauseVmRequest.ProtoReflect.Descriptor instead. -func (*PauseVmRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{19} -} - -func (x *PauseVmRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -type PauseVmResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - State VmState `protobuf:"varint,2,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *PauseVmResponse) Reset() { - *x = PauseVmResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[20] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *PauseVmResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*PauseVmResponse) ProtoMessage() {} - -func (x *PauseVmResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[20] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use PauseVmResponse.ProtoReflect.Descriptor instead. -func (*PauseVmResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{20} -} - -func (x *PauseVmResponse) GetSuccess() bool { - if x != nil { - return x.Success - } - return false -} - -func (x *PauseVmResponse) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -type ResumeVmRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ResumeVmRequest) Reset() { - *x = ResumeVmRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[21] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ResumeVmRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ResumeVmRequest) ProtoMessage() {} - -func (x *ResumeVmRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[21] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ResumeVmRequest.ProtoReflect.Descriptor instead. -func (*ResumeVmRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{21} -} - -func (x *ResumeVmRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -type ResumeVmResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - State VmState `protobuf:"varint,2,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ResumeVmResponse) Reset() { - *x = ResumeVmResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[22] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ResumeVmResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ResumeVmResponse) ProtoMessage() {} - -func (x *ResumeVmResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[22] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ResumeVmResponse.ProtoReflect.Descriptor instead. -func (*ResumeVmResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{22} -} - -func (x *ResumeVmResponse) GetSuccess() bool { - if x != nil { - return x.Success - } - return false -} - -func (x *ResumeVmResponse) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -type RebootVmRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - // Whether to force reboot (vs graceful) - Force bool `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *RebootVmRequest) Reset() { - *x = RebootVmRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[23] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *RebootVmRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*RebootVmRequest) ProtoMessage() {} - -func (x *RebootVmRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[23] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use RebootVmRequest.ProtoReflect.Descriptor instead. -func (*RebootVmRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{23} -} - -func (x *RebootVmRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -func (x *RebootVmRequest) GetForce() bool { - if x != nil { - return x.Force - } - return false -} - -type RebootVmResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - State VmState `protobuf:"varint,2,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *RebootVmResponse) Reset() { - *x = RebootVmResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[24] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *RebootVmResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*RebootVmResponse) ProtoMessage() {} - -func (x *RebootVmResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[24] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use RebootVmResponse.ProtoReflect.Descriptor instead. -func (*RebootVmResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{24} -} - -func (x *RebootVmResponse) GetSuccess() bool { - if x != nil { - return x.Success - } - return false -} - -func (x *RebootVmResponse) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -type GetVmInfoRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetVmInfoRequest) Reset() { - *x = GetVmInfoRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[25] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetVmInfoRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetVmInfoRequest) ProtoMessage() {} - -func (x *GetVmInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[25] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetVmInfoRequest.ProtoReflect.Descriptor instead. -func (*GetVmInfoRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{25} -} - -func (x *GetVmInfoRequest) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -type GetVmInfoResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - Config *VmConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"` - State VmState `protobuf:"varint,3,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - Metrics *VmMetrics `protobuf:"bytes,4,opt,name=metrics,proto3" json:"metrics,omitempty"` - // Backend-specific information - BackendInfo map[string]string `protobuf:"bytes,5,rep,name=backend_info,json=backendInfo,proto3" json:"backend_info,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Network information if available - NetworkInfo *VmNetworkInfo `protobuf:"bytes,6,opt,name=network_info,json=networkInfo,proto3" json:"network_info,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetVmInfoResponse) Reset() { - *x = GetVmInfoResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[26] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetVmInfoResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetVmInfoResponse) ProtoMessage() {} - -func (x *GetVmInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[26] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetVmInfoResponse.ProtoReflect.Descriptor instead. -func (*GetVmInfoResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{26} -} - -func (x *GetVmInfoResponse) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -func (x *GetVmInfoResponse) GetConfig() *VmConfig { - if x != nil { - return x.Config - } - return nil -} - -func (x *GetVmInfoResponse) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -func (x *GetVmInfoResponse) GetMetrics() *VmMetrics { - if x != nil { - return x.Metrics - } - return nil -} - -func (x *GetVmInfoResponse) GetBackendInfo() map[string]string { - if x != nil { - return x.BackendInfo - } - return nil -} - -func (x *GetVmInfoResponse) GetNetworkInfo() *VmNetworkInfo { - if x != nil { - return x.NetworkInfo - } - return nil -} - -// Port mapping for VM network forwarding -type PortMapping struct { - state protoimpl.MessageState `protogen:"open.v1"` - ContainerPort int32 `protobuf:"varint,1,opt,name=container_port,json=containerPort,proto3" json:"container_port,omitempty"` // Port inside the VM - HostPort int32 `protobuf:"varint,2,opt,name=host_port,json=hostPort,proto3" json:"host_port,omitempty"` // Port on the host system - Protocol string `protobuf:"bytes,3,opt,name=protocol,proto3" json:"protocol,omitempty"` // Protocol (tcp, udp) - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *PortMapping) Reset() { - *x = PortMapping{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[27] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *PortMapping) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*PortMapping) ProtoMessage() {} - -func (x *PortMapping) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[27] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use PortMapping.ProtoReflect.Descriptor instead. -func (*PortMapping) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{27} -} - -func (x *PortMapping) GetContainerPort() int32 { - if x != nil { - return x.ContainerPort - } - return 0 -} - -func (x *PortMapping) GetHostPort() int32 { - if x != nil { - return x.HostPort - } - return 0 -} - -func (x *PortMapping) GetProtocol() string { - if x != nil { - return x.Protocol - } - return "" -} - -// Network information for a VM -type VmNetworkInfo struct { - state protoimpl.MessageState `protogen:"open.v1"` - IpAddress string `protobuf:"bytes,1,opt,name=ip_address,json=ipAddress,proto3" json:"ip_address,omitempty"` - MacAddress string `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"` - TapDevice string `protobuf:"bytes,3,opt,name=tap_device,json=tapDevice,proto3" json:"tap_device,omitempty"` - NetworkNamespace string `protobuf:"bytes,4,opt,name=network_namespace,json=networkNamespace,proto3" json:"network_namespace,omitempty"` - Gateway string `protobuf:"bytes,5,opt,name=gateway,proto3" json:"gateway,omitempty"` - DnsServers []string `protobuf:"bytes,6,rep,name=dns_servers,json=dnsServers,proto3" json:"dns_servers,omitempty"` - PortMappings []*PortMapping `protobuf:"bytes,7,rep,name=port_mappings,json=portMappings,proto3" json:"port_mappings,omitempty"` // Port forwards from host to VM - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *VmNetworkInfo) Reset() { - *x = VmNetworkInfo{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[28] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *VmNetworkInfo) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*VmNetworkInfo) ProtoMessage() {} - -func (x *VmNetworkInfo) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[28] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use VmNetworkInfo.ProtoReflect.Descriptor instead. -func (*VmNetworkInfo) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{28} -} - -func (x *VmNetworkInfo) GetIpAddress() string { - if x != nil { - return x.IpAddress - } - return "" -} - -func (x *VmNetworkInfo) GetMacAddress() string { - if x != nil { - return x.MacAddress - } - return "" -} - -func (x *VmNetworkInfo) GetTapDevice() string { - if x != nil { - return x.TapDevice - } - return "" -} - -func (x *VmNetworkInfo) GetNetworkNamespace() string { - if x != nil { - return x.NetworkNamespace - } - return "" -} - -func (x *VmNetworkInfo) GetGateway() string { - if x != nil { - return x.Gateway - } - return "" -} - -func (x *VmNetworkInfo) GetDnsServers() []string { - if x != nil { - return x.DnsServers - } - return nil -} - -func (x *VmNetworkInfo) GetPortMappings() []*PortMapping { - if x != nil { - return x.PortMappings - } - return nil -} - -type VmMetrics struct { - state protoimpl.MessageState `protogen:"open.v1"` - // CPU usage percentage (0-100) - CpuUsagePercent float64 `protobuf:"fixed64,1,opt,name=cpu_usage_percent,json=cpuUsagePercent,proto3" json:"cpu_usage_percent,omitempty"` - // Memory usage in bytes - MemoryUsageBytes int64 `protobuf:"varint,2,opt,name=memory_usage_bytes,json=memoryUsageBytes,proto3" json:"memory_usage_bytes,omitempty"` - // Network I/O statistics - NetworkStats *NetworkStats `protobuf:"bytes,3,opt,name=network_stats,json=networkStats,proto3" json:"network_stats,omitempty"` - // Storage I/O statistics - StorageStats *StorageStats `protobuf:"bytes,4,opt,name=storage_stats,json=storageStats,proto3" json:"storage_stats,omitempty"` - // VM uptime in seconds - UptimeSeconds int64 `protobuf:"varint,5,opt,name=uptime_seconds,json=uptimeSeconds,proto3" json:"uptime_seconds,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *VmMetrics) Reset() { - *x = VmMetrics{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[29] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *VmMetrics) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*VmMetrics) ProtoMessage() {} - -func (x *VmMetrics) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[29] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use VmMetrics.ProtoReflect.Descriptor instead. -func (*VmMetrics) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{29} -} - -func (x *VmMetrics) GetCpuUsagePercent() float64 { - if x != nil { - return x.CpuUsagePercent - } - return 0 -} - -func (x *VmMetrics) GetMemoryUsageBytes() int64 { - if x != nil { - return x.MemoryUsageBytes - } - return 0 -} - -func (x *VmMetrics) GetNetworkStats() *NetworkStats { - if x != nil { - return x.NetworkStats - } - return nil -} - -func (x *VmMetrics) GetStorageStats() *StorageStats { - if x != nil { - return x.StorageStats - } - return nil -} - -func (x *VmMetrics) GetUptimeSeconds() int64 { - if x != nil { - return x.UptimeSeconds - } - return 0 -} - -type NetworkStats struct { - state protoimpl.MessageState `protogen:"open.v1"` - BytesReceived int64 `protobuf:"varint,1,opt,name=bytes_received,json=bytesReceived,proto3" json:"bytes_received,omitempty"` - BytesTransmitted int64 `protobuf:"varint,2,opt,name=bytes_transmitted,json=bytesTransmitted,proto3" json:"bytes_transmitted,omitempty"` - PacketsReceived int64 `protobuf:"varint,3,opt,name=packets_received,json=packetsReceived,proto3" json:"packets_received,omitempty"` - PacketsTransmitted int64 `protobuf:"varint,4,opt,name=packets_transmitted,json=packetsTransmitted,proto3" json:"packets_transmitted,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *NetworkStats) Reset() { - *x = NetworkStats{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[30] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *NetworkStats) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*NetworkStats) ProtoMessage() {} - -func (x *NetworkStats) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[30] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use NetworkStats.ProtoReflect.Descriptor instead. -func (*NetworkStats) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{30} -} - -func (x *NetworkStats) GetBytesReceived() int64 { - if x != nil { - return x.BytesReceived - } - return 0 -} - -func (x *NetworkStats) GetBytesTransmitted() int64 { - if x != nil { - return x.BytesTransmitted - } - return 0 -} - -func (x *NetworkStats) GetPacketsReceived() int64 { - if x != nil { - return x.PacketsReceived - } - return 0 -} - -func (x *NetworkStats) GetPacketsTransmitted() int64 { - if x != nil { - return x.PacketsTransmitted - } - return 0 -} - -type StorageStats struct { - state protoimpl.MessageState `protogen:"open.v1"` - BytesRead int64 `protobuf:"varint,1,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"` - BytesWritten int64 `protobuf:"varint,2,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"` - ReadOperations int64 `protobuf:"varint,3,opt,name=read_operations,json=readOperations,proto3" json:"read_operations,omitempty"` - WriteOperations int64 `protobuf:"varint,4,opt,name=write_operations,json=writeOperations,proto3" json:"write_operations,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *StorageStats) Reset() { - *x = StorageStats{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[31] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *StorageStats) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*StorageStats) ProtoMessage() {} - -func (x *StorageStats) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[31] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use StorageStats.ProtoReflect.Descriptor instead. -func (*StorageStats) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{31} -} - -func (x *StorageStats) GetBytesRead() int64 { - if x != nil { - return x.BytesRead - } - return 0 -} - -func (x *StorageStats) GetBytesWritten() int64 { - if x != nil { - return x.BytesWritten - } - return 0 -} - -func (x *StorageStats) GetReadOperations() int64 { - if x != nil { - return x.ReadOperations - } - return 0 -} - -func (x *StorageStats) GetWriteOperations() int64 { - if x != nil { - return x.WriteOperations - } - return 0 -} - -type ListVmsRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Optional filter by state - StateFilter []VmState `protobuf:"varint,1,rep,packed,name=state_filter,json=stateFilter,proto3,enum=vmprovisioner.v1.VmState" json:"state_filter,omitempty"` - // Pagination - PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` - PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ListVmsRequest) Reset() { - *x = ListVmsRequest{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[32] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ListVmsRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListVmsRequest) ProtoMessage() {} - -func (x *ListVmsRequest) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[32] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ListVmsRequest.ProtoReflect.Descriptor instead. -func (*ListVmsRequest) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{32} -} - -func (x *ListVmsRequest) GetStateFilter() []VmState { - if x != nil { - return x.StateFilter - } - return nil -} - -func (x *ListVmsRequest) GetPageSize() int32 { - if x != nil { - return x.PageSize - } - return 0 -} - -func (x *ListVmsRequest) GetPageToken() string { - if x != nil { - return x.PageToken - } - return "" -} - -type ListVmsResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Vms []*VmInfo `protobuf:"bytes,1,rep,name=vms,proto3" json:"vms,omitempty"` - NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` - TotalCount int32 `protobuf:"varint,3,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ListVmsResponse) Reset() { - *x = ListVmsResponse{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[33] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ListVmsResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListVmsResponse) ProtoMessage() {} - -func (x *ListVmsResponse) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[33] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ListVmsResponse.ProtoReflect.Descriptor instead. -func (*ListVmsResponse) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{33} -} - -func (x *ListVmsResponse) GetVms() []*VmInfo { - if x != nil { - return x.Vms - } - return nil -} - -func (x *ListVmsResponse) GetNextPageToken() string { - if x != nil { - return x.NextPageToken - } - return "" -} - -func (x *ListVmsResponse) GetTotalCount() int32 { - if x != nil { - return x.TotalCount - } - return 0 -} - -type VmInfo struct { - state protoimpl.MessageState `protogen:"open.v1"` - VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"` - State VmState `protobuf:"varint,2,opt,name=state,proto3,enum=vmprovisioner.v1.VmState" json:"state,omitempty"` - // Basic config info (subset of full config) - VcpuCount int32 `protobuf:"varint,3,opt,name=vcpu_count,json=vcpuCount,proto3" json:"vcpu_count,omitempty"` - MemorySizeBytes int64 `protobuf:"varint,4,opt,name=memory_size_bytes,json=memorySizeBytes,proto3" json:"memory_size_bytes,omitempty"` - // Creation and modification timestamps - CreatedTimestamp int64 `protobuf:"varint,5,opt,name=created_timestamp,json=createdTimestamp,proto3" json:"created_timestamp,omitempty"` - ModifiedTimestamp int64 `protobuf:"varint,6,opt,name=modified_timestamp,json=modifiedTimestamp,proto3" json:"modified_timestamp,omitempty"` - // Metadata - Metadata map[string]string `protobuf:"bytes,7,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Customer identifier - CustomerId string `protobuf:"bytes,8,opt,name=customer_id,json=customerId,proto3" json:"customer_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *VmInfo) Reset() { - *x = VmInfo{} - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[34] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *VmInfo) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*VmInfo) ProtoMessage() {} - -func (x *VmInfo) ProtoReflect() protoreflect.Message { - mi := &file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes[34] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use VmInfo.ProtoReflect.Descriptor instead. -func (*VmInfo) Descriptor() ([]byte, []int) { - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP(), []int{34} -} - -func (x *VmInfo) GetVmId() string { - if x != nil { - return x.VmId - } - return "" -} - -func (x *VmInfo) GetState() VmState { - if x != nil { - return x.State - } - return VmState_VM_STATE_UNSPECIFIED -} - -func (x *VmInfo) GetVcpuCount() int32 { - if x != nil { - return x.VcpuCount - } - return 0 -} - -func (x *VmInfo) GetMemorySizeBytes() int64 { - if x != nil { - return x.MemorySizeBytes - } - return 0 -} - -func (x *VmInfo) GetCreatedTimestamp() int64 { - if x != nil { - return x.CreatedTimestamp - } - return 0 -} - -func (x *VmInfo) GetModifiedTimestamp() int64 { - if x != nil { - return x.ModifiedTimestamp - } - return 0 -} - -func (x *VmInfo) GetMetadata() map[string]string { - if x != nil { - return x.Metadata - } - return nil -} - -func (x *VmInfo) GetCustomerId() string { - if x != nil { - return x.CustomerId - } - return "" -} - -var File_deploy_metald_proto_vmprovisioner_v1_vm_proto protoreflect.FileDescriptor - -const file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDesc = "" + - "\n" + - "-deploy/metald/proto/vmprovisioner/v1/vm.proto\x12\x10vmprovisioner.v1\"\xda\x03\n" + - "\bVmConfig\x12-\n" + - "\x03cpu\x18\x01 \x01(\v2\x1b.vmprovisioner.v1.CpuConfigR\x03cpu\x126\n" + - "\x06memory\x18\x02 \x01(\v2\x1e.vmprovisioner.v1.MemoryConfigR\x06memory\x120\n" + - "\x04boot\x18\x03 \x01(\v2\x1c.vmprovisioner.v1.BootConfigR\x04boot\x129\n" + - "\astorage\x18\x04 \x03(\v2\x1f.vmprovisioner.v1.StorageDeviceR\astorage\x12<\n" + - "\anetwork\x18\x05 \x03(\v2\".vmprovisioner.v1.NetworkInterfaceR\anetwork\x129\n" + - "\aconsole\x18\x06 \x01(\v2\x1f.vmprovisioner.v1.ConsoleConfigR\aconsole\x12D\n" + - "\bmetadata\x18\a \x03(\v2(.vmprovisioner.v1.VmConfig.MetadataEntryR\bmetadata\x1a;\n" + - "\rMetadataEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x8f\x02\n" + - "\tCpuConfig\x12\x1d\n" + - "\n" + - "vcpu_count\x18\x01 \x01(\x05R\tvcpuCount\x12$\n" + - "\x0emax_vcpu_count\x18\x02 \x01(\x05R\fmaxVcpuCount\x129\n" + - "\btopology\x18\x03 \x01(\v2\x1d.vmprovisioner.v1.CpuTopologyR\btopology\x12E\n" + - "\bfeatures\x18\x04 \x03(\v2).vmprovisioner.v1.CpuConfig.FeaturesEntryR\bfeatures\x1a;\n" + - "\rFeaturesEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"{\n" + - "\vCpuTopology\x12\x18\n" + - "\asockets\x18\x01 \x01(\x05R\asockets\x12(\n" + - "\x10cores_per_socket\x18\x02 \x01(\x05R\x0ecoresPerSocket\x12(\n" + - "\x10threads_per_core\x18\x03 \x01(\x05R\x0ethreadsPerCore\"\xff\x01\n" + - "\fMemoryConfig\x12\x1d\n" + - "\n" + - "size_bytes\x18\x01 \x01(\x03R\tsizeBytes\x12'\n" + - "\x0fhotplug_enabled\x18\x02 \x01(\bR\x0ehotplugEnabled\x12$\n" + - "\x0emax_size_bytes\x18\x03 \x01(\x03R\fmaxSizeBytes\x12E\n" + - "\abacking\x18\x04 \x03(\v2+.vmprovisioner.v1.MemoryConfig.BackingEntryR\abacking\x1a:\n" + - "\fBackingEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x81\x02\n" + - "\n" + - "BootConfig\x12\x1f\n" + - "\vkernel_path\x18\x01 \x01(\tR\n" + - "kernelPath\x12\x1f\n" + - "\vinitrd_path\x18\x02 \x01(\tR\n" + - "initrdPath\x12\x1f\n" + - "\vkernel_args\x18\x03 \x01(\tR\n" + - "kernelArgs\x12P\n" + - "\fboot_options\x18\x04 \x03(\v2-.vmprovisioner.v1.BootConfig.BootOptionsEntryR\vbootOptions\x1a>\n" + - "\x10BootOptionsEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xa1\x02\n" + - "\rStorageDevice\x12\x0e\n" + - "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + - "\x04path\x18\x02 \x01(\tR\x04path\x12\x1b\n" + - "\tread_only\x18\x03 \x01(\bR\breadOnly\x12$\n" + - "\x0eis_root_device\x18\x04 \x01(\bR\fisRootDevice\x12%\n" + - "\x0einterface_type\x18\x05 \x01(\tR\rinterfaceType\x12F\n" + - "\aoptions\x18\x06 \x03(\v2,.vmprovisioner.v1.StorageDevice.OptionsEntryR\aoptions\x1a:\n" + - "\fOptionsEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc3\x04\n" + - "\x10NetworkInterface\x12\x0e\n" + - "\x02id\x18\x01 \x01(\tR\x02id\x12\x1f\n" + - "\vmac_address\x18\x02 \x01(\tR\n" + - "macAddress\x12\x1d\n" + - "\n" + - "tap_device\x18\x03 \x01(\tR\ttapDevice\x12%\n" + - "\x0einterface_type\x18\x04 \x01(\tR\rinterfaceType\x12I\n" + - "\aoptions\x18\x05 \x03(\v2/.vmprovisioner.v1.NetworkInterface.OptionsEntryR\aoptions\x12=\n" + - "\vipv4_config\x18\x06 \x01(\v2\x1c.vmprovisioner.v1.IPv4ConfigR\n" + - "ipv4Config\x12=\n" + - "\vipv6_config\x18\a \x01(\v2\x1c.vmprovisioner.v1.IPv6ConfigR\n" + - "ipv6Config\x121\n" + - "\x04mode\x18\b \x01(\x0e2\x1d.vmprovisioner.v1.NetworkModeR\x04mode\x12?\n" + - "\rrx_rate_limit\x18\n" + - " \x01(\v2\x1b.vmprovisioner.v1.RateLimitR\vrxRateLimit\x12?\n" + - "\rtx_rate_limit\x18\v \x01(\v2\x1b.vmprovisioner.v1.RateLimitR\vtxRateLimit\x1a:\n" + - "\fOptionsEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x8f\x01\n" + - "\n" + - "IPv4Config\x12\x18\n" + - "\aaddress\x18\x01 \x01(\tR\aaddress\x12\x18\n" + - "\anetmask\x18\x02 \x01(\tR\anetmask\x12\x18\n" + - "\agateway\x18\x03 \x01(\tR\agateway\x12\x1f\n" + - "\vdns_servers\x18\x04 \x03(\tR\n" + - "dnsServers\x12\x12\n" + - "\x04dhcp\x18\x05 \x01(\bR\x04dhcp\"\xea\x01\n" + - "\n" + - "IPv6Config\x12\x18\n" + - "\aaddress\x18\x01 \x01(\tR\aaddress\x12#\n" + - "\rprefix_length\x18\x02 \x01(\x05R\fprefixLength\x12\x18\n" + - "\agateway\x18\x03 \x01(\tR\agateway\x12\x1f\n" + - "\vdns_servers\x18\x04 \x03(\tR\n" + - "dnsServers\x12\x14\n" + - "\x05slaac\x18\x05 \x01(\bR\x05slaac\x12-\n" + - "\x12privacy_extensions\x18\x06 \x01(\bR\x11privacyExtensions\x12\x1d\n" + - "\n" + - "link_local\x18\a \x01(\tR\tlinkLocal\"`\n" + - "\tRateLimit\x12\x1c\n" + - "\tbandwidth\x18\x01 \x01(\x03R\tbandwidth\x12\x1f\n" + - "\vrefill_time\x18\x02 \x01(\x03R\n" + - "refillTime\x12\x14\n" + - "\x05burst\x18\x03 \x01(\x03R\x05burst\"z\n" + - "\rConsoleConfig\x12\x18\n" + - "\aenabled\x18\x01 \x01(\bR\aenabled\x12\x16\n" + - "\x06output\x18\x02 \x01(\tR\x06output\x12\x14\n" + - "\x05input\x18\x03 \x01(\tR\x05input\x12!\n" + - "\fconsole_type\x18\x04 \x01(\tR\vconsoleType\"{\n" + - "\x0fCreateVmRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\x122\n" + - "\x06config\x18\x02 \x01(\v2\x1a.vmprovisioner.v1.VmConfigR\x06config\x12\x1f\n" + - "\vcustomer_id\x18\x03 \x01(\tR\n" + - "customerId\"X\n" + - "\x10CreateVmResponse\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\x12/\n" + - "\x05state\x18\x02 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\"<\n" + - "\x0fDeleteVmRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\x12\x14\n" + - "\x05force\x18\x02 \x01(\bR\x05force\",\n" + - "\x10DeleteVmResponse\x12\x18\n" + - "\asuccess\x18\x01 \x01(\bR\asuccess\"$\n" + - "\rBootVmRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\"[\n" + - "\x0eBootVmResponse\x12\x18\n" + - "\asuccess\x18\x01 \x01(\bR\asuccess\x12/\n" + - "\x05state\x18\x02 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\"g\n" + - "\x11ShutdownVmRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\x12\x14\n" + - "\x05force\x18\x02 \x01(\bR\x05force\x12'\n" + - "\x0ftimeout_seconds\x18\x03 \x01(\x05R\x0etimeoutSeconds\"_\n" + - "\x12ShutdownVmResponse\x12\x18\n" + - "\asuccess\x18\x01 \x01(\bR\asuccess\x12/\n" + - "\x05state\x18\x02 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\"%\n" + - "\x0ePauseVmRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\"\\\n" + - "\x0fPauseVmResponse\x12\x18\n" + - "\asuccess\x18\x01 \x01(\bR\asuccess\x12/\n" + - "\x05state\x18\x02 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\"&\n" + - "\x0fResumeVmRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\"]\n" + - "\x10ResumeVmResponse\x12\x18\n" + - "\asuccess\x18\x01 \x01(\bR\asuccess\x12/\n" + - "\x05state\x18\x02 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\"<\n" + - "\x0fRebootVmRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\x12\x14\n" + - "\x05force\x18\x02 \x01(\bR\x05force\"]\n" + - "\x10RebootVmResponse\x12\x18\n" + - "\asuccess\x18\x01 \x01(\bR\asuccess\x12/\n" + - "\x05state\x18\x02 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\"'\n" + - "\x10GetVmInfoRequest\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\"\xa1\x03\n" + - "\x11GetVmInfoResponse\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\x122\n" + - "\x06config\x18\x02 \x01(\v2\x1a.vmprovisioner.v1.VmConfigR\x06config\x12/\n" + - "\x05state\x18\x03 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\x125\n" + - "\ametrics\x18\x04 \x01(\v2\x1b.vmprovisioner.v1.VmMetricsR\ametrics\x12W\n" + - "\fbackend_info\x18\x05 \x03(\v24.vmprovisioner.v1.GetVmInfoResponse.BackendInfoEntryR\vbackendInfo\x12B\n" + - "\fnetwork_info\x18\x06 \x01(\v2\x1f.vmprovisioner.v1.VmNetworkInfoR\vnetworkInfo\x1a>\n" + - "\x10BackendInfoEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"m\n" + - "\vPortMapping\x12%\n" + - "\x0econtainer_port\x18\x01 \x01(\x05R\rcontainerPort\x12\x1b\n" + - "\thost_port\x18\x02 \x01(\x05R\bhostPort\x12\x1a\n" + - "\bprotocol\x18\x03 \x01(\tR\bprotocol\"\x9a\x02\n" + - "\rVmNetworkInfo\x12\x1d\n" + - "\n" + - "ip_address\x18\x01 \x01(\tR\tipAddress\x12\x1f\n" + - "\vmac_address\x18\x02 \x01(\tR\n" + - "macAddress\x12\x1d\n" + - "\n" + - "tap_device\x18\x03 \x01(\tR\ttapDevice\x12+\n" + - "\x11network_namespace\x18\x04 \x01(\tR\x10networkNamespace\x12\x18\n" + - "\agateway\x18\x05 \x01(\tR\agateway\x12\x1f\n" + - "\vdns_servers\x18\x06 \x03(\tR\n" + - "dnsServers\x12B\n" + - "\rport_mappings\x18\a \x03(\v2\x1d.vmprovisioner.v1.PortMappingR\fportMappings\"\x96\x02\n" + - "\tVmMetrics\x12*\n" + - "\x11cpu_usage_percent\x18\x01 \x01(\x01R\x0fcpuUsagePercent\x12,\n" + - "\x12memory_usage_bytes\x18\x02 \x01(\x03R\x10memoryUsageBytes\x12C\n" + - "\rnetwork_stats\x18\x03 \x01(\v2\x1e.vmprovisioner.v1.NetworkStatsR\fnetworkStats\x12C\n" + - "\rstorage_stats\x18\x04 \x01(\v2\x1e.vmprovisioner.v1.StorageStatsR\fstorageStats\x12%\n" + - "\x0euptime_seconds\x18\x05 \x01(\x03R\ruptimeSeconds\"\xbe\x01\n" + - "\fNetworkStats\x12%\n" + - "\x0ebytes_received\x18\x01 \x01(\x03R\rbytesReceived\x12+\n" + - "\x11bytes_transmitted\x18\x02 \x01(\x03R\x10bytesTransmitted\x12)\n" + - "\x10packets_received\x18\x03 \x01(\x03R\x0fpacketsReceived\x12/\n" + - "\x13packets_transmitted\x18\x04 \x01(\x03R\x12packetsTransmitted\"\xa6\x01\n" + - "\fStorageStats\x12\x1d\n" + - "\n" + - "bytes_read\x18\x01 \x01(\x03R\tbytesRead\x12#\n" + - "\rbytes_written\x18\x02 \x01(\x03R\fbytesWritten\x12'\n" + - "\x0fread_operations\x18\x03 \x01(\x03R\x0ereadOperations\x12)\n" + - "\x10write_operations\x18\x04 \x01(\x03R\x0fwriteOperations\"\x8a\x01\n" + - "\x0eListVmsRequest\x12<\n" + - "\fstate_filter\x18\x01 \x03(\x0e2\x19.vmprovisioner.v1.VmStateR\vstateFilter\x12\x1b\n" + - "\tpage_size\x18\x02 \x01(\x05R\bpageSize\x12\x1d\n" + - "\n" + - "page_token\x18\x03 \x01(\tR\tpageToken\"\x86\x01\n" + - "\x0fListVmsResponse\x12*\n" + - "\x03vms\x18\x01 \x03(\v2\x18.vmprovisioner.v1.VmInfoR\x03vms\x12&\n" + - "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\x12\x1f\n" + - "\vtotal_count\x18\x03 \x01(\x05R\n" + - "totalCount\"\x97\x03\n" + - "\x06VmInfo\x12\x13\n" + - "\x05vm_id\x18\x01 \x01(\tR\x04vmId\x12/\n" + - "\x05state\x18\x02 \x01(\x0e2\x19.vmprovisioner.v1.VmStateR\x05state\x12\x1d\n" + - "\n" + - "vcpu_count\x18\x03 \x01(\x05R\tvcpuCount\x12*\n" + - "\x11memory_size_bytes\x18\x04 \x01(\x03R\x0fmemorySizeBytes\x12+\n" + - "\x11created_timestamp\x18\x05 \x01(\x03R\x10createdTimestamp\x12-\n" + - "\x12modified_timestamp\x18\x06 \x01(\x03R\x11modifiedTimestamp\x12B\n" + - "\bmetadata\x18\a \x03(\v2&.vmprovisioner.v1.VmInfo.MetadataEntryR\bmetadata\x12\x1f\n" + - "\vcustomer_id\x18\b \x01(\tR\n" + - "customerId\x1a;\n" + - "\rMetadataEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01*{\n" + - "\aVmState\x12\x18\n" + - "\x14VM_STATE_UNSPECIFIED\x10\x00\x12\x14\n" + - "\x10VM_STATE_CREATED\x10\x01\x12\x14\n" + - "\x10VM_STATE_RUNNING\x10\x02\x12\x13\n" + - "\x0fVM_STATE_PAUSED\x10\x03\x12\x15\n" + - "\x11VM_STATE_SHUTDOWN\x10\x04*\x80\x01\n" + - "\vNetworkMode\x12\x1c\n" + - "\x18NETWORK_MODE_UNSPECIFIED\x10\x00\x12\x1b\n" + - "\x17NETWORK_MODE_DUAL_STACK\x10\x01\x12\x1a\n" + - "\x16NETWORK_MODE_IPV4_ONLY\x10\x02\x12\x1a\n" + - "\x16NETWORK_MODE_IPV6_ONLY\x10\x032\xf3\x05\n" + - "\tVmService\x12Q\n" + - "\bCreateVm\x12!.vmprovisioner.v1.CreateVmRequest\x1a\".vmprovisioner.v1.CreateVmResponse\x12Q\n" + - "\bDeleteVm\x12!.vmprovisioner.v1.DeleteVmRequest\x1a\".vmprovisioner.v1.DeleteVmResponse\x12K\n" + - "\x06BootVm\x12\x1f.vmprovisioner.v1.BootVmRequest\x1a .vmprovisioner.v1.BootVmResponse\x12W\n" + - "\n" + - "ShutdownVm\x12#.vmprovisioner.v1.ShutdownVmRequest\x1a$.vmprovisioner.v1.ShutdownVmResponse\x12N\n" + - "\aPauseVm\x12 .vmprovisioner.v1.PauseVmRequest\x1a!.vmprovisioner.v1.PauseVmResponse\x12Q\n" + - "\bResumeVm\x12!.vmprovisioner.v1.ResumeVmRequest\x1a\".vmprovisioner.v1.ResumeVmResponse\x12Q\n" + - "\bRebootVm\x12!.vmprovisioner.v1.RebootVmRequest\x1a\".vmprovisioner.v1.RebootVmResponse\x12T\n" + - "\tGetVmInfo\x12\".vmprovisioner.v1.GetVmInfoRequest\x1a#.vmprovisioner.v1.GetVmInfoResponse\x12N\n" + - "\aListVms\x12 .vmprovisioner.v1.ListVmsRequest\x1a!.vmprovisioner.v1.ListVmsResponseB-Z+metald/gen/vmprovisioner/v1;vmprovisionerv1b\x06proto3" - -var ( - file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescOnce sync.Once - file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescData []byte -) - -func file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescGZIP() []byte { - file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescOnce.Do(func() { - file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDesc), len(file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDesc))) - }) - return file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDescData -} - -var file_deploy_metald_proto_vmprovisioner_v1_vm_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes = make([]protoimpl.MessageInfo, 43) -var file_deploy_metald_proto_vmprovisioner_v1_vm_proto_goTypes = []any{ - (VmState)(0), // 0: vmprovisioner.v1.VmState - (NetworkMode)(0), // 1: vmprovisioner.v1.NetworkMode - (*VmConfig)(nil), // 2: vmprovisioner.v1.VmConfig - (*CpuConfig)(nil), // 3: vmprovisioner.v1.CpuConfig - (*CpuTopology)(nil), // 4: vmprovisioner.v1.CpuTopology - (*MemoryConfig)(nil), // 5: vmprovisioner.v1.MemoryConfig - (*BootConfig)(nil), // 6: vmprovisioner.v1.BootConfig - (*StorageDevice)(nil), // 7: vmprovisioner.v1.StorageDevice - (*NetworkInterface)(nil), // 8: vmprovisioner.v1.NetworkInterface - (*IPv4Config)(nil), // 9: vmprovisioner.v1.IPv4Config - (*IPv6Config)(nil), // 10: vmprovisioner.v1.IPv6Config - (*RateLimit)(nil), // 11: vmprovisioner.v1.RateLimit - (*ConsoleConfig)(nil), // 12: vmprovisioner.v1.ConsoleConfig - (*CreateVmRequest)(nil), // 13: vmprovisioner.v1.CreateVmRequest - (*CreateVmResponse)(nil), // 14: vmprovisioner.v1.CreateVmResponse - (*DeleteVmRequest)(nil), // 15: vmprovisioner.v1.DeleteVmRequest - (*DeleteVmResponse)(nil), // 16: vmprovisioner.v1.DeleteVmResponse - (*BootVmRequest)(nil), // 17: vmprovisioner.v1.BootVmRequest - (*BootVmResponse)(nil), // 18: vmprovisioner.v1.BootVmResponse - (*ShutdownVmRequest)(nil), // 19: vmprovisioner.v1.ShutdownVmRequest - (*ShutdownVmResponse)(nil), // 20: vmprovisioner.v1.ShutdownVmResponse - (*PauseVmRequest)(nil), // 21: vmprovisioner.v1.PauseVmRequest - (*PauseVmResponse)(nil), // 22: vmprovisioner.v1.PauseVmResponse - (*ResumeVmRequest)(nil), // 23: vmprovisioner.v1.ResumeVmRequest - (*ResumeVmResponse)(nil), // 24: vmprovisioner.v1.ResumeVmResponse - (*RebootVmRequest)(nil), // 25: vmprovisioner.v1.RebootVmRequest - (*RebootVmResponse)(nil), // 26: vmprovisioner.v1.RebootVmResponse - (*GetVmInfoRequest)(nil), // 27: vmprovisioner.v1.GetVmInfoRequest - (*GetVmInfoResponse)(nil), // 28: vmprovisioner.v1.GetVmInfoResponse - (*PortMapping)(nil), // 29: vmprovisioner.v1.PortMapping - (*VmNetworkInfo)(nil), // 30: vmprovisioner.v1.VmNetworkInfo - (*VmMetrics)(nil), // 31: vmprovisioner.v1.VmMetrics - (*NetworkStats)(nil), // 32: vmprovisioner.v1.NetworkStats - (*StorageStats)(nil), // 33: vmprovisioner.v1.StorageStats - (*ListVmsRequest)(nil), // 34: vmprovisioner.v1.ListVmsRequest - (*ListVmsResponse)(nil), // 35: vmprovisioner.v1.ListVmsResponse - (*VmInfo)(nil), // 36: vmprovisioner.v1.VmInfo - nil, // 37: vmprovisioner.v1.VmConfig.MetadataEntry - nil, // 38: vmprovisioner.v1.CpuConfig.FeaturesEntry - nil, // 39: vmprovisioner.v1.MemoryConfig.BackingEntry - nil, // 40: vmprovisioner.v1.BootConfig.BootOptionsEntry - nil, // 41: vmprovisioner.v1.StorageDevice.OptionsEntry - nil, // 42: vmprovisioner.v1.NetworkInterface.OptionsEntry - nil, // 43: vmprovisioner.v1.GetVmInfoResponse.BackendInfoEntry - nil, // 44: vmprovisioner.v1.VmInfo.MetadataEntry -} -var file_deploy_metald_proto_vmprovisioner_v1_vm_proto_depIdxs = []int32{ - 3, // 0: vmprovisioner.v1.VmConfig.cpu:type_name -> vmprovisioner.v1.CpuConfig - 5, // 1: vmprovisioner.v1.VmConfig.memory:type_name -> vmprovisioner.v1.MemoryConfig - 6, // 2: vmprovisioner.v1.VmConfig.boot:type_name -> vmprovisioner.v1.BootConfig - 7, // 3: vmprovisioner.v1.VmConfig.storage:type_name -> vmprovisioner.v1.StorageDevice - 8, // 4: vmprovisioner.v1.VmConfig.network:type_name -> vmprovisioner.v1.NetworkInterface - 12, // 5: vmprovisioner.v1.VmConfig.console:type_name -> vmprovisioner.v1.ConsoleConfig - 37, // 6: vmprovisioner.v1.VmConfig.metadata:type_name -> vmprovisioner.v1.VmConfig.MetadataEntry - 4, // 7: vmprovisioner.v1.CpuConfig.topology:type_name -> vmprovisioner.v1.CpuTopology - 38, // 8: vmprovisioner.v1.CpuConfig.features:type_name -> vmprovisioner.v1.CpuConfig.FeaturesEntry - 39, // 9: vmprovisioner.v1.MemoryConfig.backing:type_name -> vmprovisioner.v1.MemoryConfig.BackingEntry - 40, // 10: vmprovisioner.v1.BootConfig.boot_options:type_name -> vmprovisioner.v1.BootConfig.BootOptionsEntry - 41, // 11: vmprovisioner.v1.StorageDevice.options:type_name -> vmprovisioner.v1.StorageDevice.OptionsEntry - 42, // 12: vmprovisioner.v1.NetworkInterface.options:type_name -> vmprovisioner.v1.NetworkInterface.OptionsEntry - 9, // 13: vmprovisioner.v1.NetworkInterface.ipv4_config:type_name -> vmprovisioner.v1.IPv4Config - 10, // 14: vmprovisioner.v1.NetworkInterface.ipv6_config:type_name -> vmprovisioner.v1.IPv6Config - 1, // 15: vmprovisioner.v1.NetworkInterface.mode:type_name -> vmprovisioner.v1.NetworkMode - 11, // 16: vmprovisioner.v1.NetworkInterface.rx_rate_limit:type_name -> vmprovisioner.v1.RateLimit - 11, // 17: vmprovisioner.v1.NetworkInterface.tx_rate_limit:type_name -> vmprovisioner.v1.RateLimit - 2, // 18: vmprovisioner.v1.CreateVmRequest.config:type_name -> vmprovisioner.v1.VmConfig - 0, // 19: vmprovisioner.v1.CreateVmResponse.state:type_name -> vmprovisioner.v1.VmState - 0, // 20: vmprovisioner.v1.BootVmResponse.state:type_name -> vmprovisioner.v1.VmState - 0, // 21: vmprovisioner.v1.ShutdownVmResponse.state:type_name -> vmprovisioner.v1.VmState - 0, // 22: vmprovisioner.v1.PauseVmResponse.state:type_name -> vmprovisioner.v1.VmState - 0, // 23: vmprovisioner.v1.ResumeVmResponse.state:type_name -> vmprovisioner.v1.VmState - 0, // 24: vmprovisioner.v1.RebootVmResponse.state:type_name -> vmprovisioner.v1.VmState - 2, // 25: vmprovisioner.v1.GetVmInfoResponse.config:type_name -> vmprovisioner.v1.VmConfig - 0, // 26: vmprovisioner.v1.GetVmInfoResponse.state:type_name -> vmprovisioner.v1.VmState - 31, // 27: vmprovisioner.v1.GetVmInfoResponse.metrics:type_name -> vmprovisioner.v1.VmMetrics - 43, // 28: vmprovisioner.v1.GetVmInfoResponse.backend_info:type_name -> vmprovisioner.v1.GetVmInfoResponse.BackendInfoEntry - 30, // 29: vmprovisioner.v1.GetVmInfoResponse.network_info:type_name -> vmprovisioner.v1.VmNetworkInfo - 29, // 30: vmprovisioner.v1.VmNetworkInfo.port_mappings:type_name -> vmprovisioner.v1.PortMapping - 32, // 31: vmprovisioner.v1.VmMetrics.network_stats:type_name -> vmprovisioner.v1.NetworkStats - 33, // 32: vmprovisioner.v1.VmMetrics.storage_stats:type_name -> vmprovisioner.v1.StorageStats - 0, // 33: vmprovisioner.v1.ListVmsRequest.state_filter:type_name -> vmprovisioner.v1.VmState - 36, // 34: vmprovisioner.v1.ListVmsResponse.vms:type_name -> vmprovisioner.v1.VmInfo - 0, // 35: vmprovisioner.v1.VmInfo.state:type_name -> vmprovisioner.v1.VmState - 44, // 36: vmprovisioner.v1.VmInfo.metadata:type_name -> vmprovisioner.v1.VmInfo.MetadataEntry - 13, // 37: vmprovisioner.v1.VmService.CreateVm:input_type -> vmprovisioner.v1.CreateVmRequest - 15, // 38: vmprovisioner.v1.VmService.DeleteVm:input_type -> vmprovisioner.v1.DeleteVmRequest - 17, // 39: vmprovisioner.v1.VmService.BootVm:input_type -> vmprovisioner.v1.BootVmRequest - 19, // 40: vmprovisioner.v1.VmService.ShutdownVm:input_type -> vmprovisioner.v1.ShutdownVmRequest - 21, // 41: vmprovisioner.v1.VmService.PauseVm:input_type -> vmprovisioner.v1.PauseVmRequest - 23, // 42: vmprovisioner.v1.VmService.ResumeVm:input_type -> vmprovisioner.v1.ResumeVmRequest - 25, // 43: vmprovisioner.v1.VmService.RebootVm:input_type -> vmprovisioner.v1.RebootVmRequest - 27, // 44: vmprovisioner.v1.VmService.GetVmInfo:input_type -> vmprovisioner.v1.GetVmInfoRequest - 34, // 45: vmprovisioner.v1.VmService.ListVms:input_type -> vmprovisioner.v1.ListVmsRequest - 14, // 46: vmprovisioner.v1.VmService.CreateVm:output_type -> vmprovisioner.v1.CreateVmResponse - 16, // 47: vmprovisioner.v1.VmService.DeleteVm:output_type -> vmprovisioner.v1.DeleteVmResponse - 18, // 48: vmprovisioner.v1.VmService.BootVm:output_type -> vmprovisioner.v1.BootVmResponse - 20, // 49: vmprovisioner.v1.VmService.ShutdownVm:output_type -> vmprovisioner.v1.ShutdownVmResponse - 22, // 50: vmprovisioner.v1.VmService.PauseVm:output_type -> vmprovisioner.v1.PauseVmResponse - 24, // 51: vmprovisioner.v1.VmService.ResumeVm:output_type -> vmprovisioner.v1.ResumeVmResponse - 26, // 52: vmprovisioner.v1.VmService.RebootVm:output_type -> vmprovisioner.v1.RebootVmResponse - 28, // 53: vmprovisioner.v1.VmService.GetVmInfo:output_type -> vmprovisioner.v1.GetVmInfoResponse - 35, // 54: vmprovisioner.v1.VmService.ListVms:output_type -> vmprovisioner.v1.ListVmsResponse - 46, // [46:55] is the sub-list for method output_type - 37, // [37:46] is the sub-list for method input_type - 37, // [37:37] is the sub-list for extension type_name - 37, // [37:37] is the sub-list for extension extendee - 0, // [0:37] is the sub-list for field type_name -} - -func init() { file_deploy_metald_proto_vmprovisioner_v1_vm_proto_init() } -func file_deploy_metald_proto_vmprovisioner_v1_vm_proto_init() { - if File_deploy_metald_proto_vmprovisioner_v1_vm_proto != nil { - return - } - type x struct{} - out := protoimpl.TypeBuilder{ - File: protoimpl.DescBuilder{ - GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: unsafe.Slice(unsafe.StringData(file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDesc), len(file_deploy_metald_proto_vmprovisioner_v1_vm_proto_rawDesc)), - NumEnums: 2, - NumMessages: 43, - NumExtensions: 0, - NumServices: 1, - }, - GoTypes: file_deploy_metald_proto_vmprovisioner_v1_vm_proto_goTypes, - DependencyIndexes: file_deploy_metald_proto_vmprovisioner_v1_vm_proto_depIdxs, - EnumInfos: file_deploy_metald_proto_vmprovisioner_v1_vm_proto_enumTypes, - MessageInfos: file_deploy_metald_proto_vmprovisioner_v1_vm_proto_msgTypes, - }.Build() - File_deploy_metald_proto_vmprovisioner_v1_vm_proto = out.File - file_deploy_metald_proto_vmprovisioner_v1_vm_proto_goTypes = nil - file_deploy_metald_proto_vmprovisioner_v1_vm_proto_depIdxs = nil -} diff --git a/go/gen/deploy/metald/proto/vmprovisioner/v1/vmprovisionerv1connect/vm.connect.go b/go/gen/deploy/metald/proto/vmprovisioner/v1/vmprovisionerv1connect/vm.connect.go deleted file mode 100644 index 1340426a05..0000000000 --- a/go/gen/deploy/metald/proto/vmprovisioner/v1/vmprovisionerv1connect/vm.connect.go +++ /dev/null @@ -1,362 +0,0 @@ -// Code generated by protoc-gen-connect-go. DO NOT EDIT. -// -// Source: deploy/metald/proto/vmprovisioner/v1/vm.proto - -package vmprovisionerv1connect - -import ( - connect "connectrpc.com/connect" - context "context" - errors "errors" - v1 "metald/gen/vmprovisioner/v1" - http "net/http" - strings "strings" -) - -// This is a compile-time assertion to ensure that this generated file and the connect package are -// compatible. If you get a compiler error that this constant is not defined, this code was -// generated with a version of connect newer than the one compiled into your binary. You can fix the -// problem by either regenerating this code with an older version of connect or updating the connect -// version compiled into your binary. -const _ = connect.IsAtLeastVersion1_13_0 - -const ( - // VmServiceName is the fully-qualified name of the VmService service. - VmServiceName = "vmprovisioner.v1.VmService" -) - -// These constants are the fully-qualified names of the RPCs defined in this package. They're -// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. -// -// Note that these are different from the fully-qualified method names used by -// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to -// reflection-formatted method names, remove the leading slash and convert the remaining slash to a -// period. -const ( - // VmServiceCreateVmProcedure is the fully-qualified name of the VmService's CreateVm RPC. - VmServiceCreateVmProcedure = "/vmprovisioner.v1.VmService/CreateVm" - // VmServiceDeleteVmProcedure is the fully-qualified name of the VmService's DeleteVm RPC. - VmServiceDeleteVmProcedure = "/vmprovisioner.v1.VmService/DeleteVm" - // VmServiceBootVmProcedure is the fully-qualified name of the VmService's BootVm RPC. - VmServiceBootVmProcedure = "/vmprovisioner.v1.VmService/BootVm" - // VmServiceShutdownVmProcedure is the fully-qualified name of the VmService's ShutdownVm RPC. - VmServiceShutdownVmProcedure = "/vmprovisioner.v1.VmService/ShutdownVm" - // VmServicePauseVmProcedure is the fully-qualified name of the VmService's PauseVm RPC. - VmServicePauseVmProcedure = "/vmprovisioner.v1.VmService/PauseVm" - // VmServiceResumeVmProcedure is the fully-qualified name of the VmService's ResumeVm RPC. - VmServiceResumeVmProcedure = "/vmprovisioner.v1.VmService/ResumeVm" - // VmServiceRebootVmProcedure is the fully-qualified name of the VmService's RebootVm RPC. - VmServiceRebootVmProcedure = "/vmprovisioner.v1.VmService/RebootVm" - // VmServiceGetVmInfoProcedure is the fully-qualified name of the VmService's GetVmInfo RPC. - VmServiceGetVmInfoProcedure = "/vmprovisioner.v1.VmService/GetVmInfo" - // VmServiceListVmsProcedure is the fully-qualified name of the VmService's ListVms RPC. - VmServiceListVmsProcedure = "/vmprovisioner.v1.VmService/ListVms" -) - -// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. -var ( - vmServiceServiceDescriptor = v1.File_deploy_metald_proto_vmprovisioner_v1_vm_proto.Services().ByName("VmService") - vmServiceCreateVmMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("CreateVm") - vmServiceDeleteVmMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("DeleteVm") - vmServiceBootVmMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("BootVm") - vmServiceShutdownVmMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("ShutdownVm") - vmServicePauseVmMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("PauseVm") - vmServiceResumeVmMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("ResumeVm") - vmServiceRebootVmMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("RebootVm") - vmServiceGetVmInfoMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("GetVmInfo") - vmServiceListVmsMethodDescriptor = vmServiceServiceDescriptor.Methods().ByName("ListVms") -) - -// VmServiceClient is a client for the vmprovisioner.v1.VmService service. -type VmServiceClient interface { - // CreateVm creates a new virtual machine instance - CreateVm(context.Context, *connect.Request[v1.CreateVmRequest]) (*connect.Response[v1.CreateVmResponse], error) - // DeleteVm removes a virtual machine instance - DeleteVm(context.Context, *connect.Request[v1.DeleteVmRequest]) (*connect.Response[v1.DeleteVmResponse], error) - // BootVm starts a created virtual machine - BootVm(context.Context, *connect.Request[v1.BootVmRequest]) (*connect.Response[v1.BootVmResponse], error) - // ShutdownVm gracefully stops a running virtual machine - ShutdownVm(context.Context, *connect.Request[v1.ShutdownVmRequest]) (*connect.Response[v1.ShutdownVmResponse], error) - // PauseVm pauses a running virtual machine - PauseVm(context.Context, *connect.Request[v1.PauseVmRequest]) (*connect.Response[v1.PauseVmResponse], error) - // ResumeVm resumes a paused virtual machine - ResumeVm(context.Context, *connect.Request[v1.ResumeVmRequest]) (*connect.Response[v1.ResumeVmResponse], error) - // RebootVm restarts a running virtual machine - RebootVm(context.Context, *connect.Request[v1.RebootVmRequest]) (*connect.Response[v1.RebootVmResponse], error) - // GetVmInfo retrieves virtual machine status and configuration - GetVmInfo(context.Context, *connect.Request[v1.GetVmInfoRequest]) (*connect.Response[v1.GetVmInfoResponse], error) - // ListVms lists all virtual machines managed by this service - ListVms(context.Context, *connect.Request[v1.ListVmsRequest]) (*connect.Response[v1.ListVmsResponse], error) -} - -// NewVmServiceClient constructs a client for the vmprovisioner.v1.VmService service. By default, it -// uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends -// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or -// connect.WithGRPCWeb() options. -// -// The URL supplied here should be the base URL for the Connect or gRPC server (for example, -// http://api.acme.com or https://acme.com/grpc). -func NewVmServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) VmServiceClient { - baseURL = strings.TrimRight(baseURL, "/") - return &vmServiceClient{ - createVm: connect.NewClient[v1.CreateVmRequest, v1.CreateVmResponse]( - httpClient, - baseURL+VmServiceCreateVmProcedure, - connect.WithSchema(vmServiceCreateVmMethodDescriptor), - connect.WithClientOptions(opts...), - ), - deleteVm: connect.NewClient[v1.DeleteVmRequest, v1.DeleteVmResponse]( - httpClient, - baseURL+VmServiceDeleteVmProcedure, - connect.WithSchema(vmServiceDeleteVmMethodDescriptor), - connect.WithClientOptions(opts...), - ), - bootVm: connect.NewClient[v1.BootVmRequest, v1.BootVmResponse]( - httpClient, - baseURL+VmServiceBootVmProcedure, - connect.WithSchema(vmServiceBootVmMethodDescriptor), - connect.WithClientOptions(opts...), - ), - shutdownVm: connect.NewClient[v1.ShutdownVmRequest, v1.ShutdownVmResponse]( - httpClient, - baseURL+VmServiceShutdownVmProcedure, - connect.WithSchema(vmServiceShutdownVmMethodDescriptor), - connect.WithClientOptions(opts...), - ), - pauseVm: connect.NewClient[v1.PauseVmRequest, v1.PauseVmResponse]( - httpClient, - baseURL+VmServicePauseVmProcedure, - connect.WithSchema(vmServicePauseVmMethodDescriptor), - connect.WithClientOptions(opts...), - ), - resumeVm: connect.NewClient[v1.ResumeVmRequest, v1.ResumeVmResponse]( - httpClient, - baseURL+VmServiceResumeVmProcedure, - connect.WithSchema(vmServiceResumeVmMethodDescriptor), - connect.WithClientOptions(opts...), - ), - rebootVm: connect.NewClient[v1.RebootVmRequest, v1.RebootVmResponse]( - httpClient, - baseURL+VmServiceRebootVmProcedure, - connect.WithSchema(vmServiceRebootVmMethodDescriptor), - connect.WithClientOptions(opts...), - ), - getVmInfo: connect.NewClient[v1.GetVmInfoRequest, v1.GetVmInfoResponse]( - httpClient, - baseURL+VmServiceGetVmInfoProcedure, - connect.WithSchema(vmServiceGetVmInfoMethodDescriptor), - connect.WithClientOptions(opts...), - ), - listVms: connect.NewClient[v1.ListVmsRequest, v1.ListVmsResponse]( - httpClient, - baseURL+VmServiceListVmsProcedure, - connect.WithSchema(vmServiceListVmsMethodDescriptor), - connect.WithClientOptions(opts...), - ), - } -} - -// vmServiceClient implements VmServiceClient. -type vmServiceClient struct { - createVm *connect.Client[v1.CreateVmRequest, v1.CreateVmResponse] - deleteVm *connect.Client[v1.DeleteVmRequest, v1.DeleteVmResponse] - bootVm *connect.Client[v1.BootVmRequest, v1.BootVmResponse] - shutdownVm *connect.Client[v1.ShutdownVmRequest, v1.ShutdownVmResponse] - pauseVm *connect.Client[v1.PauseVmRequest, v1.PauseVmResponse] - resumeVm *connect.Client[v1.ResumeVmRequest, v1.ResumeVmResponse] - rebootVm *connect.Client[v1.RebootVmRequest, v1.RebootVmResponse] - getVmInfo *connect.Client[v1.GetVmInfoRequest, v1.GetVmInfoResponse] - listVms *connect.Client[v1.ListVmsRequest, v1.ListVmsResponse] -} - -// CreateVm calls vmprovisioner.v1.VmService.CreateVm. -func (c *vmServiceClient) CreateVm(ctx context.Context, req *connect.Request[v1.CreateVmRequest]) (*connect.Response[v1.CreateVmResponse], error) { - return c.createVm.CallUnary(ctx, req) -} - -// DeleteVm calls vmprovisioner.v1.VmService.DeleteVm. -func (c *vmServiceClient) DeleteVm(ctx context.Context, req *connect.Request[v1.DeleteVmRequest]) (*connect.Response[v1.DeleteVmResponse], error) { - return c.deleteVm.CallUnary(ctx, req) -} - -// BootVm calls vmprovisioner.v1.VmService.BootVm. -func (c *vmServiceClient) BootVm(ctx context.Context, req *connect.Request[v1.BootVmRequest]) (*connect.Response[v1.BootVmResponse], error) { - return c.bootVm.CallUnary(ctx, req) -} - -// ShutdownVm calls vmprovisioner.v1.VmService.ShutdownVm. -func (c *vmServiceClient) ShutdownVm(ctx context.Context, req *connect.Request[v1.ShutdownVmRequest]) (*connect.Response[v1.ShutdownVmResponse], error) { - return c.shutdownVm.CallUnary(ctx, req) -} - -// PauseVm calls vmprovisioner.v1.VmService.PauseVm. -func (c *vmServiceClient) PauseVm(ctx context.Context, req *connect.Request[v1.PauseVmRequest]) (*connect.Response[v1.PauseVmResponse], error) { - return c.pauseVm.CallUnary(ctx, req) -} - -// ResumeVm calls vmprovisioner.v1.VmService.ResumeVm. -func (c *vmServiceClient) ResumeVm(ctx context.Context, req *connect.Request[v1.ResumeVmRequest]) (*connect.Response[v1.ResumeVmResponse], error) { - return c.resumeVm.CallUnary(ctx, req) -} - -// RebootVm calls vmprovisioner.v1.VmService.RebootVm. -func (c *vmServiceClient) RebootVm(ctx context.Context, req *connect.Request[v1.RebootVmRequest]) (*connect.Response[v1.RebootVmResponse], error) { - return c.rebootVm.CallUnary(ctx, req) -} - -// GetVmInfo calls vmprovisioner.v1.VmService.GetVmInfo. -func (c *vmServiceClient) GetVmInfo(ctx context.Context, req *connect.Request[v1.GetVmInfoRequest]) (*connect.Response[v1.GetVmInfoResponse], error) { - return c.getVmInfo.CallUnary(ctx, req) -} - -// ListVms calls vmprovisioner.v1.VmService.ListVms. -func (c *vmServiceClient) ListVms(ctx context.Context, req *connect.Request[v1.ListVmsRequest]) (*connect.Response[v1.ListVmsResponse], error) { - return c.listVms.CallUnary(ctx, req) -} - -// VmServiceHandler is an implementation of the vmprovisioner.v1.VmService service. -type VmServiceHandler interface { - // CreateVm creates a new virtual machine instance - CreateVm(context.Context, *connect.Request[v1.CreateVmRequest]) (*connect.Response[v1.CreateVmResponse], error) - // DeleteVm removes a virtual machine instance - DeleteVm(context.Context, *connect.Request[v1.DeleteVmRequest]) (*connect.Response[v1.DeleteVmResponse], error) - // BootVm starts a created virtual machine - BootVm(context.Context, *connect.Request[v1.BootVmRequest]) (*connect.Response[v1.BootVmResponse], error) - // ShutdownVm gracefully stops a running virtual machine - ShutdownVm(context.Context, *connect.Request[v1.ShutdownVmRequest]) (*connect.Response[v1.ShutdownVmResponse], error) - // PauseVm pauses a running virtual machine - PauseVm(context.Context, *connect.Request[v1.PauseVmRequest]) (*connect.Response[v1.PauseVmResponse], error) - // ResumeVm resumes a paused virtual machine - ResumeVm(context.Context, *connect.Request[v1.ResumeVmRequest]) (*connect.Response[v1.ResumeVmResponse], error) - // RebootVm restarts a running virtual machine - RebootVm(context.Context, *connect.Request[v1.RebootVmRequest]) (*connect.Response[v1.RebootVmResponse], error) - // GetVmInfo retrieves virtual machine status and configuration - GetVmInfo(context.Context, *connect.Request[v1.GetVmInfoRequest]) (*connect.Response[v1.GetVmInfoResponse], error) - // ListVms lists all virtual machines managed by this service - ListVms(context.Context, *connect.Request[v1.ListVmsRequest]) (*connect.Response[v1.ListVmsResponse], error) -} - -// NewVmServiceHandler builds an HTTP handler from the service implementation. It returns the path -// on which to mount the handler and the handler itself. -// -// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf -// and JSON codecs. They also support gzip compression. -func NewVmServiceHandler(svc VmServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { - vmServiceCreateVmHandler := connect.NewUnaryHandler( - VmServiceCreateVmProcedure, - svc.CreateVm, - connect.WithSchema(vmServiceCreateVmMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServiceDeleteVmHandler := connect.NewUnaryHandler( - VmServiceDeleteVmProcedure, - svc.DeleteVm, - connect.WithSchema(vmServiceDeleteVmMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServiceBootVmHandler := connect.NewUnaryHandler( - VmServiceBootVmProcedure, - svc.BootVm, - connect.WithSchema(vmServiceBootVmMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServiceShutdownVmHandler := connect.NewUnaryHandler( - VmServiceShutdownVmProcedure, - svc.ShutdownVm, - connect.WithSchema(vmServiceShutdownVmMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServicePauseVmHandler := connect.NewUnaryHandler( - VmServicePauseVmProcedure, - svc.PauseVm, - connect.WithSchema(vmServicePauseVmMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServiceResumeVmHandler := connect.NewUnaryHandler( - VmServiceResumeVmProcedure, - svc.ResumeVm, - connect.WithSchema(vmServiceResumeVmMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServiceRebootVmHandler := connect.NewUnaryHandler( - VmServiceRebootVmProcedure, - svc.RebootVm, - connect.WithSchema(vmServiceRebootVmMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServiceGetVmInfoHandler := connect.NewUnaryHandler( - VmServiceGetVmInfoProcedure, - svc.GetVmInfo, - connect.WithSchema(vmServiceGetVmInfoMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - vmServiceListVmsHandler := connect.NewUnaryHandler( - VmServiceListVmsProcedure, - svc.ListVms, - connect.WithSchema(vmServiceListVmsMethodDescriptor), - connect.WithHandlerOptions(opts...), - ) - return "/vmprovisioner.v1.VmService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - switch r.URL.Path { - case VmServiceCreateVmProcedure: - vmServiceCreateVmHandler.ServeHTTP(w, r) - case VmServiceDeleteVmProcedure: - vmServiceDeleteVmHandler.ServeHTTP(w, r) - case VmServiceBootVmProcedure: - vmServiceBootVmHandler.ServeHTTP(w, r) - case VmServiceShutdownVmProcedure: - vmServiceShutdownVmHandler.ServeHTTP(w, r) - case VmServicePauseVmProcedure: - vmServicePauseVmHandler.ServeHTTP(w, r) - case VmServiceResumeVmProcedure: - vmServiceResumeVmHandler.ServeHTTP(w, r) - case VmServiceRebootVmProcedure: - vmServiceRebootVmHandler.ServeHTTP(w, r) - case VmServiceGetVmInfoProcedure: - vmServiceGetVmInfoHandler.ServeHTTP(w, r) - case VmServiceListVmsProcedure: - vmServiceListVmsHandler.ServeHTTP(w, r) - default: - http.NotFound(w, r) - } - }) -} - -// UnimplementedVmServiceHandler returns CodeUnimplemented from all methods. -type UnimplementedVmServiceHandler struct{} - -func (UnimplementedVmServiceHandler) CreateVm(context.Context, *connect.Request[v1.CreateVmRequest]) (*connect.Response[v1.CreateVmResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.CreateVm is not implemented")) -} - -func (UnimplementedVmServiceHandler) DeleteVm(context.Context, *connect.Request[v1.DeleteVmRequest]) (*connect.Response[v1.DeleteVmResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.DeleteVm is not implemented")) -} - -func (UnimplementedVmServiceHandler) BootVm(context.Context, *connect.Request[v1.BootVmRequest]) (*connect.Response[v1.BootVmResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.BootVm is not implemented")) -} - -func (UnimplementedVmServiceHandler) ShutdownVm(context.Context, *connect.Request[v1.ShutdownVmRequest]) (*connect.Response[v1.ShutdownVmResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.ShutdownVm is not implemented")) -} - -func (UnimplementedVmServiceHandler) PauseVm(context.Context, *connect.Request[v1.PauseVmRequest]) (*connect.Response[v1.PauseVmResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.PauseVm is not implemented")) -} - -func (UnimplementedVmServiceHandler) ResumeVm(context.Context, *connect.Request[v1.ResumeVmRequest]) (*connect.Response[v1.ResumeVmResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.ResumeVm is not implemented")) -} - -func (UnimplementedVmServiceHandler) RebootVm(context.Context, *connect.Request[v1.RebootVmRequest]) (*connect.Response[v1.RebootVmResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.RebootVm is not implemented")) -} - -func (UnimplementedVmServiceHandler) GetVmInfo(context.Context, *connect.Request[v1.GetVmInfoRequest]) (*connect.Response[v1.GetVmInfoResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.GetVmInfo is not implemented")) -} - -func (UnimplementedVmServiceHandler) ListVms(context.Context, *connect.Request[v1.ListVmsRequest]) (*connect.Response[v1.ListVmsResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("vmprovisioner.v1.VmService.ListVms is not implemented")) -} diff --git a/go/gen/proto/ctrl/v1/version.pb.go b/go/gen/proto/ctrl/v1/version.pb.go index c8adf0ed09..2c26a6dfc6 100644 --- a/go/gen/proto/ctrl/v1/version.pb.go +++ b/go/gen/proto/ctrl/v1/version.pb.go @@ -9,7 +9,6 @@ package ctrlv1 import ( protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" - timestamppb "google.golang.org/protobuf/types/known/timestamppb" reflect "reflect" sync "sync" unsafe "unsafe" @@ -386,13 +385,15 @@ type Version struct { // Topology configuration Topology *Topology `protobuf:"bytes,10,opt,name=topology,proto3" json:"topology,omitempty"` // Timestamps - CreatedAt *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` + CreatedAt int64 `protobuf:"varint,11,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + UpdatedAt int64 `protobuf:"varint,12,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` // Associated hostnames for this version Hostnames []string `protobuf:"bytes,13,rep,name=hostnames,proto3" json:"hostnames,omitempty"` // Build information RootfsImageId string `protobuf:"bytes,14,opt,name=rootfs_image_id,json=rootfsImageId,proto3" json:"rootfs_image_id,omitempty"` BuildId string `protobuf:"bytes,15,opt,name=build_id,json=buildId,proto3" json:"build_id,omitempty"` + // Deployment steps + Steps []*VersionStep `protobuf:"bytes,16,rep,name=steps,proto3" json:"steps,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -497,18 +498,18 @@ func (x *Version) GetTopology() *Topology { return nil } -func (x *Version) GetCreatedAt() *timestamppb.Timestamp { +func (x *Version) GetCreatedAt() int64 { if x != nil { return x.CreatedAt } - return nil + return 0 } -func (x *Version) GetUpdatedAt() *timestamppb.Timestamp { +func (x *Version) GetUpdatedAt() int64 { if x != nil { return x.UpdatedAt } - return nil + return 0 } func (x *Version) GetHostnames() []string { @@ -532,6 +533,81 @@ func (x *Version) GetBuildId() string { return "" } +func (x *Version) GetSteps() []*VersionStep { + if x != nil { + return x.Steps + } + return nil +} + +type VersionStep struct { + state protoimpl.MessageState `protogen:"open.v1"` + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + ErrorMessage string `protobuf:"bytes,3,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"` + CreatedAt int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VersionStep) Reset() { + *x = VersionStep{} + mi := &file_proto_ctrl_v1_version_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VersionStep) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VersionStep) ProtoMessage() {} + +func (x *VersionStep) ProtoReflect() protoreflect.Message { + mi := &file_proto_ctrl_v1_version_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VersionStep.ProtoReflect.Descriptor instead. +func (*VersionStep) Descriptor() ([]byte, []int) { + return file_proto_ctrl_v1_version_proto_rawDescGZIP(), []int{5} +} + +func (x *VersionStep) GetStatus() string { + if x != nil { + return x.Status + } + return "" +} + +func (x *VersionStep) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *VersionStep) GetErrorMessage() string { + if x != nil { + return x.ErrorMessage + } + return "" +} + +func (x *VersionStep) GetCreatedAt() int64 { + if x != nil { + return x.CreatedAt + } + return 0 +} + type Topology struct { state protoimpl.MessageState `protogen:"open.v1"` CpuMillicores int32 `protobuf:"varint,1,opt,name=cpu_millicores,json=cpuMillicores,proto3" json:"cpu_millicores,omitempty"` @@ -548,7 +624,7 @@ type Topology struct { func (x *Topology) Reset() { *x = Topology{} - mi := &file_proto_ctrl_v1_version_proto_msgTypes[5] + mi := &file_proto_ctrl_v1_version_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -560,7 +636,7 @@ func (x *Topology) String() string { func (*Topology) ProtoMessage() {} func (x *Topology) ProtoReflect() protoreflect.Message { - mi := &file_proto_ctrl_v1_version_proto_msgTypes[5] + mi := &file_proto_ctrl_v1_version_proto_msgTypes[6] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -573,7 +649,7 @@ func (x *Topology) ProtoReflect() protoreflect.Message { // Deprecated: Use Topology.ProtoReflect.Descriptor instead. func (*Topology) Descriptor() ([]byte, []int) { - return file_proto_ctrl_v1_version_proto_rawDescGZIP(), []int{5} + return file_proto_ctrl_v1_version_proto_rawDescGZIP(), []int{6} } func (x *Topology) GetCpuMillicores() int32 { @@ -629,7 +705,7 @@ type RegionalConfig struct { func (x *RegionalConfig) Reset() { *x = RegionalConfig{} - mi := &file_proto_ctrl_v1_version_proto_msgTypes[6] + mi := &file_proto_ctrl_v1_version_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -641,7 +717,7 @@ func (x *RegionalConfig) String() string { func (*RegionalConfig) ProtoMessage() {} func (x *RegionalConfig) ProtoReflect() protoreflect.Message { - mi := &file_proto_ctrl_v1_version_proto_msgTypes[6] + mi := &file_proto_ctrl_v1_version_proto_msgTypes[7] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -654,7 +730,7 @@ func (x *RegionalConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use RegionalConfig.ProtoReflect.Descriptor instead. func (*RegionalConfig) Descriptor() ([]byte, []int) { - return file_proto_ctrl_v1_version_proto_rawDescGZIP(), []int{6} + return file_proto_ctrl_v1_version_proto_rawDescGZIP(), []int{7} } func (x *RegionalConfig) GetRegion() string { @@ -682,7 +758,7 @@ var File_proto_ctrl_v1_version_proto protoreflect.FileDescriptor const file_proto_ctrl_v1_version_proto_rawDesc = "" + "\n" + - "\x1bproto/ctrl/v1/version.proto\x12\actrl.v1\x1a\x1fgoogle/protobuf/timestamp.proto\"\x9d\x02\n" + + "\x1bproto/ctrl/v1/version.proto\x12\actrl.v1\"\x9d\x02\n" + "\x14CreateVersionRequest\x12!\n" + "\fworkspace_id\x18\x01 \x01(\tR\vworkspaceId\x12\x1d\n" + "\n" + @@ -701,7 +777,7 @@ const file_proto_ctrl_v1_version_proto_rawDesc = "" + "\n" + "version_id\x18\x01 \x01(\tR\tversionId\"@\n" + "\x12GetVersionResponse\x12*\n" + - "\aversion\x18\x01 \x01(\v2\x10.ctrl.v1.VersionR\aversion\"\xcc\x05\n" + + "\aversion\x18\x01 \x01(\v2\x10.ctrl.v1.VersionR\aversion\"\xc0\x05\n" + "\aVersion\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12!\n" + "\fworkspace_id\x18\x02 \x01(\tR\vworkspaceId\x12\x1d\n" + @@ -715,17 +791,24 @@ const file_proto_ctrl_v1_version_proto_rawDesc = "" + "\rerror_message\x18\b \x01(\tR\ferrorMessage\x12_\n" + "\x15environment_variables\x18\t \x03(\v2*.ctrl.v1.Version.EnvironmentVariablesEntryR\x14environmentVariables\x12-\n" + "\btopology\x18\n" + - " \x01(\v2\x11.ctrl.v1.TopologyR\btopology\x129\n" + + " \x01(\v2\x11.ctrl.v1.TopologyR\btopology\x12\x1d\n" + "\n" + - "created_at\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x129\n" + + "created_at\x18\v \x01(\x03R\tcreatedAt\x12\x1d\n" + "\n" + - "updated_at\x18\f \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\x12\x1c\n" + + "updated_at\x18\f \x01(\x03R\tupdatedAt\x12\x1c\n" + "\thostnames\x18\r \x03(\tR\thostnames\x12&\n" + "\x0frootfs_image_id\x18\x0e \x01(\tR\rrootfsImageId\x12\x19\n" + - "\bbuild_id\x18\x0f \x01(\tR\abuildId\x1aG\n" + + "\bbuild_id\x18\x0f \x01(\tR\abuildId\x12*\n" + + "\x05steps\x18\x10 \x03(\v2\x14.ctrl.v1.VersionStepR\x05steps\x1aG\n" + "\x19EnvironmentVariablesEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xf3\x01\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x83\x01\n" + + "\vVersionStep\x12\x16\n" + + "\x06status\x18\x01 \x01(\tR\x06status\x12\x18\n" + + "\amessage\x18\x02 \x01(\tR\amessage\x12#\n" + + "\rerror_message\x18\x03 \x01(\tR\ferrorMessage\x12\x1d\n" + + "\n" + + "created_at\x18\x04 \x01(\x03R\tcreatedAt\"\xf3\x01\n" + "\bTopology\x12%\n" + "\x0ecpu_millicores\x18\x01 \x01(\x05R\rcpuMillicores\x12\x1b\n" + "\tmemory_mb\x18\x02 \x01(\x05R\bmemoryMb\x121\n" + @@ -768,7 +851,7 @@ func file_proto_ctrl_v1_version_proto_rawDescGZIP() []byte { } var file_proto_ctrl_v1_version_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_proto_ctrl_v1_version_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_proto_ctrl_v1_version_proto_msgTypes = make([]protoimpl.MessageInfo, 9) var file_proto_ctrl_v1_version_proto_goTypes = []any{ (VersionStatus)(0), // 0: ctrl.v1.VersionStatus (SourceType)(0), // 1: ctrl.v1.SourceType @@ -777,30 +860,29 @@ var file_proto_ctrl_v1_version_proto_goTypes = []any{ (*GetVersionRequest)(nil), // 4: ctrl.v1.GetVersionRequest (*GetVersionResponse)(nil), // 5: ctrl.v1.GetVersionResponse (*Version)(nil), // 6: ctrl.v1.Version - (*Topology)(nil), // 7: ctrl.v1.Topology - (*RegionalConfig)(nil), // 8: ctrl.v1.RegionalConfig - nil, // 9: ctrl.v1.Version.EnvironmentVariablesEntry - (*timestamppb.Timestamp)(nil), // 10: google.protobuf.Timestamp + (*VersionStep)(nil), // 7: ctrl.v1.VersionStep + (*Topology)(nil), // 8: ctrl.v1.Topology + (*RegionalConfig)(nil), // 9: ctrl.v1.RegionalConfig + nil, // 10: ctrl.v1.Version.EnvironmentVariablesEntry } var file_proto_ctrl_v1_version_proto_depIdxs = []int32{ 1, // 0: ctrl.v1.CreateVersionRequest.source_type:type_name -> ctrl.v1.SourceType 0, // 1: ctrl.v1.CreateVersionResponse.status:type_name -> ctrl.v1.VersionStatus 6, // 2: ctrl.v1.GetVersionResponse.version:type_name -> ctrl.v1.Version 0, // 3: ctrl.v1.Version.status:type_name -> ctrl.v1.VersionStatus - 9, // 4: ctrl.v1.Version.environment_variables:type_name -> ctrl.v1.Version.EnvironmentVariablesEntry - 7, // 5: ctrl.v1.Version.topology:type_name -> ctrl.v1.Topology - 10, // 6: ctrl.v1.Version.created_at:type_name -> google.protobuf.Timestamp - 10, // 7: ctrl.v1.Version.updated_at:type_name -> google.protobuf.Timestamp - 8, // 8: ctrl.v1.Topology.regions:type_name -> ctrl.v1.RegionalConfig - 2, // 9: ctrl.v1.VersionService.CreateVersion:input_type -> ctrl.v1.CreateVersionRequest - 4, // 10: ctrl.v1.VersionService.GetVersion:input_type -> ctrl.v1.GetVersionRequest - 3, // 11: ctrl.v1.VersionService.CreateVersion:output_type -> ctrl.v1.CreateVersionResponse - 5, // 12: ctrl.v1.VersionService.GetVersion:output_type -> ctrl.v1.GetVersionResponse - 11, // [11:13] is the sub-list for method output_type - 9, // [9:11] is the sub-list for method input_type - 9, // [9:9] is the sub-list for extension type_name - 9, // [9:9] is the sub-list for extension extendee - 0, // [0:9] is the sub-list for field type_name + 10, // 4: ctrl.v1.Version.environment_variables:type_name -> ctrl.v1.Version.EnvironmentVariablesEntry + 8, // 5: ctrl.v1.Version.topology:type_name -> ctrl.v1.Topology + 7, // 6: ctrl.v1.Version.steps:type_name -> ctrl.v1.VersionStep + 9, // 7: ctrl.v1.Topology.regions:type_name -> ctrl.v1.RegionalConfig + 2, // 8: ctrl.v1.VersionService.CreateVersion:input_type -> ctrl.v1.CreateVersionRequest + 4, // 9: ctrl.v1.VersionService.GetVersion:input_type -> ctrl.v1.GetVersionRequest + 3, // 10: ctrl.v1.VersionService.CreateVersion:output_type -> ctrl.v1.CreateVersionResponse + 5, // 11: ctrl.v1.VersionService.GetVersion:output_type -> ctrl.v1.GetVersionResponse + 10, // [10:12] is the sub-list for method output_type + 8, // [8:10] is the sub-list for method input_type + 8, // [8:8] is the sub-list for extension type_name + 8, // [8:8] is the sub-list for extension extendee + 0, // [0:8] is the sub-list for field type_name } func init() { file_proto_ctrl_v1_version_proto_init() } @@ -814,7 +896,7 @@ func file_proto_ctrl_v1_version_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto_ctrl_v1_version_proto_rawDesc), len(file_proto_ctrl_v1_version_proto_rawDesc)), NumEnums: 2, - NumMessages: 8, + NumMessages: 9, NumExtensions: 0, NumServices: 1, }, diff --git a/go/go.mod b/go/go.mod index 5177696857..9473a48830 100644 --- a/go/go.mod +++ b/go/go.mod @@ -28,9 +28,10 @@ require ( github.com/shirou/gopsutil/v4 v4.25.5 github.com/sqlc-dev/sqlc v1.28.0 github.com/stretchr/testify v1.10.0 - github.com/unkeyed/unkey/go/deploy/assetmanagerd v0.0.0-20250709084132-0dd195e4c51b - github.com/unkeyed/unkey/go/deploy/billaged v0.0.0-20250709084132-0dd195e4c51b - github.com/unkeyed/unkey/go/deploy/builderd v0.0.0-20250709084132-0dd195e4c51b + github.com/unkeyed/unkey/go/deploy/assetmanagerd v0.0.0-20250710211506-eee7a93abd66 + github.com/unkeyed/unkey/go/deploy/billaged v0.0.0-20250710211506-eee7a93abd66 + github.com/unkeyed/unkey/go/deploy/builderd v0.0.0-20250710211506-eee7a93abd66 + github.com/unkeyed/unkey/go/deploy/pkg/tls v0.0.0-00010101000000-000000000000 github.com/urfave/cli/v3 v3.3.3 go.opentelemetry.io/contrib/bridges/otelslog v0.11.0 go.opentelemetry.io/contrib/bridges/prometheus v0.61.0 @@ -104,6 +105,7 @@ require ( github.com/getkin/kin-openapi v0.131.0 // indirect github.com/go-faster/city v1.0.1 // indirect github.com/go-faster/errors v0.7.1 // indirect + github.com/go-jose/go-jose/v4 v4.0.5 // indirect github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-ole/go-ole v1.3.0 // indirect @@ -168,10 +170,12 @@ require ( github.com/speakeasy-api/openapi-overlay v0.9.0 // indirect github.com/spf13/cobra v1.9.1 // indirect github.com/spf13/pflag v1.0.6 // indirect + github.com/spiffe/go-spiffe/v2 v2.5.0 // indirect github.com/stoewer/go-strcase v1.2.0 // indirect github.com/tetratelabs/wazero v1.8.2 // indirect github.com/tklauser/go-sysconf v0.3.15 // indirect github.com/tklauser/numcpus v0.10.0 // indirect + github.com/unkeyed/unkey/go/deploy/pkg/spiffe v0.0.0-00010101000000-000000000000 // indirect github.com/vmware-labs/yaml-jsonpath v0.3.2 // indirect github.com/wasilibs/go-pgquery v0.0.0-20240606042535-c0843d6592cc // indirect github.com/wasilibs/wazero-helpers v0.0.0-20240604052452-61d7981e9a38 // indirect @@ -181,6 +185,7 @@ require ( github.com/xeipuuv/gojsonschema v1.2.0 // indirect github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect github.com/yusufpapurcu/wmi v1.2.4 // indirect + github.com/zeebo/errs v1.4.0 // indirect go.opentelemetry.io/auto/sdk v1.1.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 // indirect go.opentelemetry.io/otel/log v0.12.2 // indirect @@ -207,4 +212,8 @@ require ( modernc.org/sqlite v1.36.2 // indirect ) +replace github.com/unkeyed/unkey/go/deploy/pkg/tls => ./deploy/pkg/tls + +replace github.com/unkeyed/unkey/go/deploy/pkg/spiffe => ./deploy/pkg/spiffe + tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen diff --git a/go/go.sum b/go/go.sum index 760287e2c7..48502e0882 100644 --- a/go/go.sum +++ b/go/go.sum @@ -153,6 +153,8 @@ github.com/go-faster/city v1.0.1 h1:4WAxSZ3V2Ws4QRDrscLEDcibJY8uf41H6AhXDrNDcGw= github.com/go-faster/city v1.0.1/go.mod h1:jKcUJId49qdW3L1qKHH/3wPeUstCVpVSXTM6vO3VcTw= github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo= +github.com/go-jose/go-jose/v4 v4.0.5 h1:M6T8+mKZl/+fNNuFHvGIzDz7BTLQPIounk/b9dw3AaE= +github.com/go-jose/go-jose/v4 v4.0.5/go.mod h1:s3P1lRrkT8igV8D9OjyL4WRyHvjB6a4JSllnOrmmBOA= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= @@ -363,6 +365,8 @@ github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo= github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0= github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spiffe/go-spiffe/v2 v2.5.0 h1:N2I01KCUkv1FAjZXJMwh95KK1ZIQLYbPfhaxw8WS0hE= +github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g= github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0= github.com/sqlc-dev/sqlc v1.28.0 h1:2QB4X22pKNpKMyb8dRLnqZwMXW6S+ZCyYCpa+3/ICcI= github.com/sqlc-dev/sqlc v1.28.0/go.mod h1:x6wDsOHH60dTX3ES9sUUxRVaROg5aFB3l3nkkjyuK1A= @@ -385,12 +389,12 @@ github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfj github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ= github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= -github.com/unkeyed/unkey/go/deploy/assetmanagerd v0.0.0-20250709084132-0dd195e4c51b h1:102XGZQrY3viWW78AQ/piW0rwSPSMljGmz6QgiNLYrw= -github.com/unkeyed/unkey/go/deploy/assetmanagerd v0.0.0-20250709084132-0dd195e4c51b/go.mod h1:0FGpQCOhGyvLQyCawTdYnLOY/1/mtPSSWndCwgaMnkc= -github.com/unkeyed/unkey/go/deploy/billaged v0.0.0-20250709084132-0dd195e4c51b h1:xrwqIkZSBoeHEG633k9gFneN3WcZbOTVSaxs+TgknLk= -github.com/unkeyed/unkey/go/deploy/billaged v0.0.0-20250709084132-0dd195e4c51b/go.mod h1:E88GqmQBLAmuRWX8bRG7Pf56Cfmut6YQApUpFVe7PuQ= -github.com/unkeyed/unkey/go/deploy/builderd v0.0.0-20250709084132-0dd195e4c51b h1:nyFQrGeZyvt5Nbcz5n9YDzUC4S2gezRoIWWKrwdLCik= -github.com/unkeyed/unkey/go/deploy/builderd v0.0.0-20250709084132-0dd195e4c51b/go.mod h1:yEwRt1cVfgrHF09ZynWIWV2MSj0tIGysTuLGBJR5TTM= +github.com/unkeyed/unkey/go/deploy/assetmanagerd v0.0.0-20250710211506-eee7a93abd66 h1:WwiWsdYvj/R+wy+COEeKNi/6/OECiG7ktUvc3N0YNH0= +github.com/unkeyed/unkey/go/deploy/assetmanagerd v0.0.0-20250710211506-eee7a93abd66/go.mod h1:0FGpQCOhGyvLQyCawTdYnLOY/1/mtPSSWndCwgaMnkc= +github.com/unkeyed/unkey/go/deploy/billaged v0.0.0-20250710211506-eee7a93abd66 h1:9aYMq5OE12FCBrMtrd1n8eSb9EqC3TINwYR1hV3+r/M= +github.com/unkeyed/unkey/go/deploy/billaged v0.0.0-20250710211506-eee7a93abd66/go.mod h1:E88GqmQBLAmuRWX8bRG7Pf56Cfmut6YQApUpFVe7PuQ= +github.com/unkeyed/unkey/go/deploy/builderd v0.0.0-20250710211506-eee7a93abd66 h1:R+URKrZgmKyo5wGX7dWVOprt3F+lb7GLPUNLvBbsSSo= +github.com/unkeyed/unkey/go/deploy/builderd v0.0.0-20250710211506-eee7a93abd66/go.mod h1:yEwRt1cVfgrHF09ZynWIWV2MSj0tIGysTuLGBJR5TTM= github.com/urfave/cli/v3 v3.3.3 h1:byCBaVdIXuLPIDm5CYZRVG6NvT7tv1ECqdU4YzlEa3I= github.com/urfave/cli/v3 v3.3.3/go.mod h1:FJSKtM/9AiiTOJL4fJ6TbMUkxBXn7GO9guZqoZtpYpo= github.com/vmware-labs/yaml-jsonpath v0.3.2 h1:/5QKeCBGdsInyDCyVNLbXyilb61MXGi9NP674f9Hobk= @@ -420,6 +424,8 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +github.com/zeebo/errs v1.4.0 h1:XNdoD/RRMKP7HD0UhJnIzUy74ISdGGxURlYG8HSWSfM= +github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= go.mongodb.org/mongo-driver v1.11.4/go.mod h1:PTSz5yu21bkT/wXpkS7WR5f0ddqw5quethTUn9WM+2g= go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= diff --git a/go/pkg/db/build_step_find_by_build_id.sql_generated.go b/go/pkg/db/build_step_find_by_build_id.sql_generated.go new file mode 100644 index 0000000000..4071a779b9 --- /dev/null +++ b/go/pkg/db/build_step_find_by_build_id.sql_generated.go @@ -0,0 +1,62 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.27.0 +// source: build_step_find_by_build_id.sql + +package db + +import ( + "context" +) + +const findVersionStepsByVersionId = `-- name: FindVersionStepsByVersionId :many +SELECT + version_id, + status, + message, + error_message, + created_at +FROM version_steps +WHERE version_id = ? +ORDER BY created_at ASC +` + +// FindVersionStepsByVersionId +// +// SELECT +// version_id, +// status, +// message, +// error_message, +// created_at +// FROM version_steps +// WHERE version_id = ? +// ORDER BY created_at ASC +func (q *Queries) FindVersionStepsByVersionId(ctx context.Context, db DBTX, versionID string) ([]VersionStep, error) { + rows, err := db.QueryContext(ctx, findVersionStepsByVersionId, versionID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []VersionStep + for rows.Next() { + var i VersionStep + if err := rows.Scan( + &i.VersionID, + &i.Status, + &i.Message, + &i.ErrorMessage, + &i.CreatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/go/pkg/db/build_step_insert.sql_generated.go b/go/pkg/db/build_step_insert.sql_generated.go new file mode 100644 index 0000000000..77f532b763 --- /dev/null +++ b/go/pkg/db/build_step_insert.sql_generated.go @@ -0,0 +1,61 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.27.0 +// source: build_step_insert.sql + +package db + +import ( + "context" + "database/sql" +) + +const insertVersionStep = `-- name: InsertVersionStep :exec +INSERT INTO version_steps ( + version_id, + status, + message, + error_message, + created_at +) VALUES ( + ?, ?, ?, ?, ? +) +ON DUPLICATE KEY UPDATE + message = VALUES(message), + error_message = VALUES(error_message), + created_at = VALUES(created_at) +` + +type InsertVersionStepParams struct { + VersionID string `db:"version_id"` + Status VersionStepsStatus `db:"status"` + Message sql.NullString `db:"message"` + ErrorMessage sql.NullString `db:"error_message"` + CreatedAt int64 `db:"created_at"` +} + +// InsertVersionStep +// +// INSERT INTO version_steps ( +// version_id, +// status, +// message, +// error_message, +// created_at +// ) VALUES ( +// ?, ?, ?, ?, ? +// ) +// ON DUPLICATE KEY UPDATE +// message = VALUES(message), +// error_message = VALUES(error_message), +// created_at = VALUES(created_at) +func (q *Queries) InsertVersionStep(ctx context.Context, db DBTX, arg InsertVersionStepParams) error { + _, err := db.ExecContext(ctx, insertVersionStep, + arg.VersionID, + arg.Status, + arg.Message, + arg.ErrorMessage, + arg.CreatedAt, + ) + return err +} diff --git a/go/pkg/db/models_generated.go b/go/pkg/db/models_generated.go index aa55a7e257..6afc493e0d 100644 --- a/go/pkg/db/models_generated.go +++ b/go/pkg/db/models_generated.go @@ -398,6 +398,55 @@ func (ns NullVercelBindingsResourceType) Value() (driver.Value, error) { return string(ns.VercelBindingsResourceType), nil } +type VersionStepsStatus string + +const ( + VersionStepsStatusPending VersionStepsStatus = "pending" + VersionStepsStatusDownloadingDockerImage VersionStepsStatus = "downloading_docker_image" + VersionStepsStatusBuildingRootfs VersionStepsStatus = "building_rootfs" + VersionStepsStatusUploadingRootfs VersionStepsStatus = "uploading_rootfs" + VersionStepsStatusCreatingVm VersionStepsStatus = "creating_vm" + VersionStepsStatusBootingVm VersionStepsStatus = "booting_vm" + VersionStepsStatusAssigningDomains VersionStepsStatus = "assigning_domains" + VersionStepsStatusCompleted VersionStepsStatus = "completed" + VersionStepsStatusFailed VersionStepsStatus = "failed" +) + +func (e *VersionStepsStatus) Scan(src interface{}) error { + switch s := src.(type) { + case []byte: + *e = VersionStepsStatus(s) + case string: + *e = VersionStepsStatus(s) + default: + return fmt.Errorf("unsupported scan type for VersionStepsStatus: %T", src) + } + return nil +} + +type NullVersionStepsStatus struct { + VersionStepsStatus VersionStepsStatus + Valid bool // Valid is true if VersionStepsStatus is not NULL +} + +// Scan implements the Scanner interface. +func (ns *NullVersionStepsStatus) Scan(value interface{}) error { + if value == nil { + ns.VersionStepsStatus, ns.Valid = "", false + return nil + } + ns.Valid = true + return ns.VersionStepsStatus.Scan(value) +} + +// Value implements the driver Valuer interface. +func (ns NullVersionStepsStatus) Value() (driver.Value, error) { + if !ns.Valid { + return nil, nil + } + return string(ns.VersionStepsStatus), nil +} + type VersionsStatus string const ( @@ -827,6 +876,14 @@ type Version struct { UpdatedAt sql.NullInt64 `db:"updated_at"` } +type VersionStep struct { + VersionID string `db:"version_id"` + Status VersionStepsStatus `db:"status"` + Message sql.NullString `db:"message"` + ErrorMessage sql.NullString `db:"error_message"` + CreatedAt int64 `db:"created_at"` +} + type Workspace struct { ID string `db:"id"` OrgID string `db:"org_id"` diff --git a/go/pkg/db/querier_generated.go b/go/pkg/db/querier_generated.go index c2679613bc..1b05cab6f6 100644 --- a/go/pkg/db/querier_generated.go +++ b/go/pkg/db/querier_generated.go @@ -317,6 +317,21 @@ type Querier interface { // WHERE role_id = ? // AND permission_id = ? FindRolePermissionByRoleAndPermissionID(ctx context.Context, db DBTX, arg FindRolePermissionByRoleAndPermissionIDParams) ([]RolesPermission, error) + //FindRoutesByVersionId + // + // SELECT + // id, + // workspace_id, + // project_id, + // hostname, + // version_id, + // is_enabled, + // created_at, + // updated_at + // FROM routes + // WHERE version_id = ? AND is_enabled = true + // ORDER BY created_at ASC + FindRoutesByVersionId(ctx context.Context, db DBTX, versionID string) ([]Route, error) //FindVersionById // // SELECT @@ -335,6 +350,18 @@ type Querier interface { // FROM `versions` // WHERE id = ? FindVersionById(ctx context.Context, db DBTX, id string) (Version, error) + //FindVersionStepsByVersionId + // + // SELECT + // version_id, + // status, + // message, + // error_message, + // created_at + // FROM version_steps + // WHERE version_id = ? + // ORDER BY created_at ASC + FindVersionStepsByVersionId(ctx context.Context, db DBTX, versionID string) ([]VersionStep, error) //FindWorkspaceByID // // SELECT id, org_id, name, partition_id, plan, tier, stripe_customer_id, stripe_subscription_id, beta_features, features, subscriptions, enabled, delete_protection, created_at_m, updated_at_m, deleted_at_m FROM `workspaces` @@ -722,6 +749,21 @@ type Querier interface { // ? // ) InsertRolePermission(ctx context.Context, db DBTX, arg InsertRolePermissionParams) error + //InsertRoute + // + // INSERT INTO routes ( + // id, + // workspace_id, + // project_id, + // hostname, + // version_id, + // is_enabled, + // created_at, + // updated_at + // ) VALUES ( + // ?, ?, ?, ?, ?, ?, ?, ? + // ) + InsertRoute(ctx context.Context, db DBTX, arg InsertRouteParams) error //InsertVersion // // INSERT INTO `versions` ( @@ -753,6 +795,22 @@ type Querier interface { // ? // ) InsertVersion(ctx context.Context, db DBTX, arg InsertVersionParams) error + //InsertVersionStep + // + // INSERT INTO version_steps ( + // version_id, + // status, + // message, + // error_message, + // created_at + // ) VALUES ( + // ?, ?, ?, ?, ? + // ) + // ON DUPLICATE KEY UPDATE + // message = VALUES(message), + // error_message = VALUES(error_message), + // created_at = VALUES(created_at) + InsertVersionStep(ctx context.Context, db DBTX, arg InsertVersionStepParams) error //InsertWorkspace // // INSERT INTO `workspaces` ( diff --git a/go/pkg/db/queries/build_step_find_by_build_id.sql b/go/pkg/db/queries/build_step_find_by_build_id.sql new file mode 100644 index 0000000000..29eef14737 --- /dev/null +++ b/go/pkg/db/queries/build_step_find_by_build_id.sql @@ -0,0 +1,10 @@ +-- name: FindVersionStepsByVersionId :many +SELECT + version_id, + status, + message, + error_message, + created_at +FROM version_steps +WHERE version_id = ? +ORDER BY created_at ASC; \ No newline at end of file diff --git a/go/pkg/db/queries/build_step_insert.sql b/go/pkg/db/queries/build_step_insert.sql new file mode 100644 index 0000000000..2bb5705e10 --- /dev/null +++ b/go/pkg/db/queries/build_step_insert.sql @@ -0,0 +1,14 @@ +-- name: InsertVersionStep :exec +INSERT INTO version_steps ( + version_id, + status, + message, + error_message, + created_at +) VALUES ( + ?, ?, ?, ?, ? +) +ON DUPLICATE KEY UPDATE + message = VALUES(message), + error_message = VALUES(error_message), + created_at = VALUES(created_at); \ No newline at end of file diff --git a/go/pkg/db/queries/route_find_by_version_id.sql b/go/pkg/db/queries/route_find_by_version_id.sql new file mode 100644 index 0000000000..b0fc6445a3 --- /dev/null +++ b/go/pkg/db/queries/route_find_by_version_id.sql @@ -0,0 +1,13 @@ +-- name: FindRoutesByVersionId :many +SELECT + id, + workspace_id, + project_id, + hostname, + version_id, + is_enabled, + created_at, + updated_at +FROM routes +WHERE version_id = ? AND is_enabled = true +ORDER BY created_at ASC; \ No newline at end of file diff --git a/go/pkg/db/queries/route_insert.sql b/go/pkg/db/queries/route_insert.sql new file mode 100644 index 0000000000..6e38ca45cc --- /dev/null +++ b/go/pkg/db/queries/route_insert.sql @@ -0,0 +1,13 @@ +-- name: InsertRoute :exec +INSERT INTO routes ( + id, + workspace_id, + project_id, + hostname, + version_id, + is_enabled, + created_at, + updated_at +) VALUES ( + ?, ?, ?, ?, ?, ?, ?, ? +); \ No newline at end of file diff --git a/go/pkg/db/route_find_by_version_id.sql_generated.go b/go/pkg/db/route_find_by_version_id.sql_generated.go new file mode 100644 index 0000000000..b7c59c3942 --- /dev/null +++ b/go/pkg/db/route_find_by_version_id.sql_generated.go @@ -0,0 +1,71 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.27.0 +// source: route_find_by_version_id.sql + +package db + +import ( + "context" +) + +const findRoutesByVersionId = `-- name: FindRoutesByVersionId :many +SELECT + id, + workspace_id, + project_id, + hostname, + version_id, + is_enabled, + created_at, + updated_at +FROM routes +WHERE version_id = ? AND is_enabled = true +ORDER BY created_at ASC +` + +// FindRoutesByVersionId +// +// SELECT +// id, +// workspace_id, +// project_id, +// hostname, +// version_id, +// is_enabled, +// created_at, +// updated_at +// FROM routes +// WHERE version_id = ? AND is_enabled = true +// ORDER BY created_at ASC +func (q *Queries) FindRoutesByVersionId(ctx context.Context, db DBTX, versionID string) ([]Route, error) { + rows, err := db.QueryContext(ctx, findRoutesByVersionId, versionID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Route + for rows.Next() { + var i Route + if err := rows.Scan( + &i.ID, + &i.WorkspaceID, + &i.ProjectID, + &i.Hostname, + &i.VersionID, + &i.IsEnabled, + &i.CreatedAt, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/go/pkg/db/route_insert.sql_generated.go b/go/pkg/db/route_insert.sql_generated.go new file mode 100644 index 0000000000..fb4a797ca6 --- /dev/null +++ b/go/pkg/db/route_insert.sql_generated.go @@ -0,0 +1,65 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.27.0 +// source: route_insert.sql + +package db + +import ( + "context" + "database/sql" +) + +const insertRoute = `-- name: InsertRoute :exec +INSERT INTO routes ( + id, + workspace_id, + project_id, + hostname, + version_id, + is_enabled, + created_at, + updated_at +) VALUES ( + ?, ?, ?, ?, ?, ?, ?, ? +) +` + +type InsertRouteParams struct { + ID string `db:"id"` + WorkspaceID string `db:"workspace_id"` + ProjectID string `db:"project_id"` + Hostname string `db:"hostname"` + VersionID string `db:"version_id"` + IsEnabled bool `db:"is_enabled"` + CreatedAt int64 `db:"created_at"` + UpdatedAt sql.NullInt64 `db:"updated_at"` +} + +// InsertRoute +// +// INSERT INTO routes ( +// id, +// workspace_id, +// project_id, +// hostname, +// version_id, +// is_enabled, +// created_at, +// updated_at +// ) VALUES ( +// ?, ?, ?, ?, ?, ?, ?, ? +// ) +func (q *Queries) InsertRoute(ctx context.Context, db DBTX, arg InsertRouteParams) error { + _, err := db.ExecContext(ctx, insertRoute, + arg.ID, + arg.WorkspaceID, + arg.ProjectID, + arg.Hostname, + arg.VersionID, + arg.IsEnabled, + arg.CreatedAt, + arg.UpdatedAt, + ) + return err +} diff --git a/go/pkg/db/schema.sql b/go/pkg/db/schema.sql index 2c5d87e241..1221c72eda 100644 --- a/go/pkg/db/schema.sql +++ b/go/pkg/db/schema.sql @@ -364,6 +364,16 @@ CREATE TABLE `builds` ( CONSTRAINT `builds_id` PRIMARY KEY(`id`) ); +CREATE TABLE `version_steps` ( + `version_id` varchar(256) NOT NULL, + `status` enum('pending','downloading_docker_image','building_rootfs','uploading_rootfs','creating_vm','booting_vm','assigning_domains','completed','failed') NOT NULL, + `message` text, + `error_message` text, + `created_at` bigint NOT NULL, + CONSTRAINT `version_steps_pk` PRIMARY KEY(`version_id`, `status`), + INDEX `idx_version_id_created_at` (`version_id`, `created_at`) +); + CREATE TABLE `versions` ( `id` varchar(256) NOT NULL, `workspace_id` varchar(256) NOT NULL, diff --git a/go/pkg/hydra/step.go b/go/pkg/hydra/step.go index eac01f17e1..c1c5ac7215 100644 --- a/go/pkg/hydra/step.go +++ b/go/pkg/hydra/step.go @@ -274,3 +274,37 @@ func Step[TResponse any](ctx WorkflowContext, stepName string, fn func(context.C return response, nil } + +// StepVoid executes a named step within a workflow that performs side effects but doesn't return a value. +// +// This is a convenience wrapper around Step for functions that only return an error. +// It's perfect for steps that perform database updates, send notifications, or other +// side effects where the result itself isn't needed by subsequent steps. +// +// Parameters: +// - ctx: The workflow context from the workflow's Run() method +// - stepName: A unique name for this step within the workflow +// - fn: The function to execute, which should be idempotent and only return an error +// +// Example usage: +// +// // Database update step +// err := hydra.StepVoid(ctx, "update-user-status", func(stepCtx context.Context) error { +// return userService.UpdateStatus(stepCtx, userID, "active") +// }) +// +// // Notification step +// err := hydra.StepVoid(ctx, "send-email", func(stepCtx context.Context) error { +// return emailService.SendWelcomeEmail(stepCtx, userEmail) +// }) +// +// Returns only an error if the step execution fails. +func StepVoid(ctx WorkflowContext, stepName string, fn func(context.Context) error) error { + _, err := Step(ctx, stepName, func(stepCtx context.Context) (*struct{}, error) { + if err := fn(stepCtx); err != nil { + return nil, err + } + return &struct{}{}, nil + }) + return err +} diff --git a/go/proto/ctrl/v1/version.proto b/go/proto/ctrl/v1/version.proto index 89a8a80380..36920bee1a 100644 --- a/go/proto/ctrl/v1/version.proto +++ b/go/proto/ctrl/v1/version.proto @@ -4,8 +4,6 @@ package ctrl.v1; option go_package = "github.com/unkeyed/unkey/go/gen/proto/ctrl/v1;ctrlv1"; -import "google/protobuf/timestamp.proto"; - // Version status enum enum VersionStatus { VERSION_STATUS_UNSPECIFIED = 0; @@ -75,8 +73,8 @@ message Version { Topology topology = 10; // Timestamps - google.protobuf.Timestamp created_at = 11; - google.protobuf.Timestamp updated_at = 12; + int64 created_at = 11; + int64 updated_at = 12; // Associated hostnames for this version repeated string hostnames = 13; @@ -84,6 +82,16 @@ message Version { // Build information string rootfs_image_id = 14; string build_id = 15; + + // Deployment steps + repeated VersionStep steps = 16; +} + +message VersionStep { + string status = 1; + string message = 2; + string error_message = 3; + int64 created_at = 4; } message Topology { diff --git a/internal/db/src/schema/builds.ts b/internal/db/src/schema/builds.ts index 1b6ad2323e..db22189736 100644 --- a/internal/db/src/schema/builds.ts +++ b/internal/db/src/schema/builds.ts @@ -1,5 +1,5 @@ import { relations } from "drizzle-orm"; -import { bigint, index, mysqlEnum, mysqlTable, text, varchar } from "drizzle-orm/mysql-core"; +import { bigint, index, mysqlEnum, mysqlTable, primaryKey, text, varchar } from "drizzle-orm/mysql-core"; import { projects } from "./projects"; import { rootfsImages } from "./rootfs_images"; import { lifecycleDates } from "./util/lifecycle_dates"; @@ -45,6 +45,21 @@ export const builds = mysqlTable( }), ); +export const versionSteps = mysqlTable( + "version_steps", + { + versionId: varchar("version_id", { length: 256 }).notNull(), + status: mysqlEnum("status", ["pending", "downloading_docker_image", "building_rootfs", "uploading_rootfs", "creating_vm", "booting_vm", "assigning_domains", "completed", "failed"]).notNull(), + message: text("message"), + errorMessage: text("error_message"), + createdAt: bigint("created_at", { mode: "number" }).notNull(), + }, + (table) => ({ + pk: primaryKey({ columns: [table.versionId, table.status] }), + versionIdCreatedAtIdx: index("idx_version_id_created_at").on(table.versionId, table.createdAt), + }), +); + export const buildsRelations = relations(builds, ({ one }) => ({ workspace: one(workspaces, { fields: [builds.workspaceId], @@ -60,3 +75,10 @@ export const buildsRelations = relations(builds, ({ one }) => ({ }), version: one(versions), })); + +export const versionStepsRelations = relations(versionSteps, ({ one }) => ({ + version: one(versions, { + fields: [versionSteps.versionId], + references: [versions.id], + }), +}));