Skip to content

Modern Docker Management, Designed for Everyone

7.6 KB
Raw Blame
package jobs

import (
	"context"
	"crypto/rand"
	"errors"
	"fmt"
	"net/http"
	"slices"
	"strconv"
	"strings"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/jobschedule"
	"github.com/spf13/cobra"
	kit "go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/cli/v2/internal/client"
	"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
	"github.com/getarcaneapp/arcane/cli/v2/internal/output"
	"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)

// Command is the parent command for background jobs and their schedules.
func Command() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "jobs",
		Aliases: []string{"job"},
		Short:   "Manage background jobs",
	}
	cmdutil.SetScope(cmdutil.ScopeResource, cmd)
	cmd.AddCommand(newSchedulesCmd())
	cmd.AddCommand(newListCmd())
	cmd.AddCommand(newRunCmd())
	return cmd
}

func newSchedulesCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "schedules",
		Short: "Manage job schedule intervals",
	}
	cmd.AddCommand(newGetCmd())
	cmd.AddCommand(newUpdateCmd())
	return cmd
}

func newGetCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:          "get",
		Short:        "Get configured job schedule intervals",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			cfg, err := c.DoJSON[jobschedule.Config](cmd.Context(), http.MethodGet, types.JobSchedules(c.EnvID()), nil)
			if err != nil {
				return fmt.Errorf("failed to get job schedules: %w", err)
			}

			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(cfg)
			}

			output.Header("Job Schedules")
			output.KeyValue("Environment health interval", cfg.EnvironmentHealthInterval)
			output.KeyValue("Event cleanup interval", cfg.EventCleanupInterval)
			output.KeyValue("Expired sessions cleanup interval", cfg.ExpiredSessionsCleanupInterval)
			return nil
		},
	}
	cmdutil.SetScope(cmdutil.ScopeRead, cmd)
	return cmd
}

func newUpdateCmd() *cobra.Command {
	var opts struct {
		environmentHealthInterval      string
		eventCleanupInterval           string
		expiredSessionsCleanupInterval string
	}
	cmd := &cobra.Command{
		Use:          "update",
		Short:        "Update job schedule intervals",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			if !slices.ContainsFunc([]string{"environment-health-interval", "event-cleanup-interval", "expired-sessions-cleanup-interval"}, cmd.Flags().Changed) {
				return errors.New("no updates provided (set at least one interval flag)")
			}
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[jobschedule.Config]{
				Method: http.MethodPut,
				Path:   types.JobSchedules(c.EnvID()),
				Body: jobschedule.Update{
					EnvironmentHealthInterval:      kit.Ternary(cmd.Flags().Changed("environment-health-interval"), &opts.environmentHealthInterval, nil),
					EventCleanupInterval:           kit.Ternary(cmd.Flags().Changed("event-cleanup-interval"), &opts.eventCleanupInterval, nil),
					ExpiredSessionsCleanupInterval: kit.Ternary(cmd.Flags().Changed("expired-sessions-cleanup-interval"), &opts.expiredSessionsCleanupInterval, nil),
				},
				FailureMessage: "failed to update job schedules",
				Render: func(data jobschedule.Config) error {
					output.Success("Job schedules updated")
					output.KeyValue("Environment health interval", data.EnvironmentHealthInterval)
					output.KeyValue("Event cleanup interval", data.EventCleanupInterval)
					output.KeyValue("Expired sessions cleanup interval", data.ExpiredSessionsCleanupInterval)
					return nil
				},
			})
		},
	}
	cmdutil.SetScope(cmdutil.ScopeFleet, cmd)
	cmd.Flags().StringVar(&opts.environmentHealthInterval, "environment-health-interval", "", "Environment health job interval (cron expression)")
	cmd.Flags().StringVar(&opts.eventCleanupInterval, "event-cleanup-interval", "", "Event cleanup job interval (cron expression)")
	cmd.Flags().StringVar(&opts.expiredSessionsCleanupInterval, "expired-sessions-cleanup-interval", "", "Expired sessions cleanup job interval (cron expression)")
	return cmd
}

func newListCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:          "list",
		Aliases:      []string{"ls"},
		Short:        "List background jobs",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			result, err := c.DoJSON[jobschedule.JobListResponse](cmd.Context(), http.MethodGet, types.Jobs(c.EnvID()), nil)
			if err != nil {
				return fmt.Errorf("failed to list jobs: %w", err)
			}

			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(result)
			}

			headers := []string{"ID", "NAME", "CATEGORY", "SCHEDULE", "NEXT RUN", "ENABLED"}
			rows := make([][]string, len(result.Jobs))
			for i, job := range result.Jobs {
				nextRun := "-"
				if job.NextRun != nil {
					nextRun = job.NextRun.Format(time.RFC3339)
				}
				rows[i] = []string{
					job.ID,
					job.Name,
					job.Category,
					job.Schedule,
					nextRun,
					strconv.FormatBool(job.Enabled),
				}
			}

			return cmdutil.PrintTable(cmd, headers, rows, cmdutil.TableSummary{Resource: "jobs"})
		},
	}
	cmdutil.SetScope(cmdutil.ScopeRead, cmd)
	return cmd
}

func newRunCmd() *cobra.Command {
	var opts struct {
		requestID string
	}
	cmd := &cobra.Command{
		Use:          "run <job-id>",
		Short:        "Queue a background job now",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			id := opts.requestID
			if id == "" {
				var value [16]byte
				_, _ = rand.Read(value[:])
				value[6] = (value[6] & 0x0f) | 0x40
				value[8] = (value[8] & 0x3f) | 0x80
				id = fmt.Sprintf("%x-%x-%x-%x-%x", value[0:4], value[4:6], value[6:8], value[8:10], value[10:16])
			}
			result, err := c.DoJSON[jobschedule.JobRunResponse](cmd.Context(), http.MethodPost, types.JobRun(c.EnvID(), args[0]), nil, http.Header{"Idempotency-Key": []string{id}})
			if err != nil {
				return fmt.Errorf("failed to queue job (reuse --request-id %s if delivery is uncertain): %w", id, err)
			}

			if !result.Success {
				return fmt.Errorf("job %s failed: %s", args[0], result.Message)
			}
			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(result)
			}
			output.Success("%s", result.Message)
			output.KeyValue("Run ID", result.RunID)
			output.KeyValue("Status", string(result.Status))
			return nil
		},
	}
	cmdutil.SetResource(jobRef, cmd)
	cmd.Flags().StringVar(&opts.requestID, "request-id", "", "Stable request ID to reuse when retrying an uncertain submission")
	return cmd
}

var jobRef = cmdutil.ResourceRef[jobschedule.JobStatus, jobschedule.JobStatus]{
	EnvironmentScoped: true, Singular: "job", Plural: "jobs", IDHint: "the job ID", ListCmd: "arcane-cli jobs list",
	SearchCandidates: func(ctx context.Context, c *client.Client, identifier string) ([]jobschedule.JobStatus, error) {
		result, err := c.DoJSON[jobschedule.JobListResponse](ctx, http.MethodGet, types.Jobs(c.EnvID()), nil)
		if err != nil {
			return nil, err
		}
		return slices.DeleteFunc(result.Jobs, func(item jobschedule.JobStatus) bool { return !strings.EqualFold(item.ID, identifier) }), nil
	},
	IdentifierOf: func(item jobschedule.JobStatus) string { return item.ID },
	Label:        func(item jobschedule.JobStatus) string { return item.Name + " (" + item.ID + ")" },
	Promote:      func(item jobschedule.JobStatus) *jobschedule.JobStatus { return &item },
}