riverui

Documentation

Index

• Variables
• func NormalizePathPrefix(prefix string) string
• type DBTXWithBegin
• type HandlerOpts
• type RiverJob
• type RiverQueue
• type Server
  • func NewServer(opts *HandlerOpts) (*Server, error)
  • func (s *Server) Handler() http.Handler
  • func (s *Server) Start(ctx context.Context) error

Variables

var FrontendIndex embed.FS

Functions

func NormalizePathPrefix

func NormalizePathPrefix(prefix string) string

Types

type DBTXWithBegin

type DBTXWithBegin interface {
	Begin(ctx context.Context) (pgx.Tx, error)
	dbsqlc.DBTX
}

type HandlerOpts

type HandlerOpts struct {
	// Client is the River client to use for API requests.
	Client *river.Client[pgx.Tx]
	// DBPool is the database connection pool to use for API requests.
	DBPool DBTXWithBegin
	// DevMode is whether the server is running in development mode.
	DevMode bool
	// LiveFS is whether to use the live filesystem for the frontend.
	LiveFS bool
	// Logger is the logger to use logging errors within the handler.
	Logger *slog.Logger
	// Prefix is the path prefix to use for the API and UI HTTP requests.
	Prefix string
}

HandlerOpts are the options for creating a new Handler.

type RiverJob

type RiverJob struct {
	ID          int64                    `json:"id"`
	Args        json.RawMessage          `json:"args"`
	Attempt     int                      `json:"attempt"`
	AttemptedAt *time.Time               `json:"attempted_at"`
	AttemptedBy []string                 `json:"attempted_by"`
	CreatedAt   time.Time                `json:"created_at"`
	Errors      []rivertype.AttemptError `json:"errors"`
	FinalizedAt *time.Time               `json:"finalized_at"`
	Kind        string                   `json:"kind"`
	MaxAttempts int                      `json:"max_attempts"`
	Metadata    json.RawMessage          `json:"metadata"`
	Priority    int                      `json:"priority"`
	Queue       string                   `json:"queue"`
	ScheduledAt time.Time                `json:"scheduled_at"`
	State       string                   `json:"state"`
	Tags        []string                 `json:"tags"`
}

type RiverQueue

type RiverQueue struct {
	CountAvailable int             `json:"count_available"`
	CountRunning   int             `json:"count_running"`
	CreatedAt      time.Time       `json:"created_at"`
	Metadata       json.RawMessage `json:"metadata"`
	Name           string          `json:"name"`
	PausedAt       *time.Time      `json:"paused_at"`
	UpdatedAt      time.Time       `json:"updated_at"`
}

type Server

type Server struct {
	// contains filtered or unexported fields
}

func NewServer

func NewServer(opts *HandlerOpts) (*Server, error)

NewServer creates a new http.Handler that serves the River UI and API.

func (*Server) Handler

func (s *Server) Handler() http.Handler

Handler returns an http.Handler that can be mounted to serve HTTP requests.

func (*Server) Start

func (s *Server) Start(ctx context.Context) error

Start starts the server's background services. Notably, this does _not_ cause the server to start listening for HTTP in any way. To do that, call Handler and mount or run it using Go's built in `net/http`.