resolver

type Checksum ¶

type Checksum struct {
	Object string
	OS     string
	Arch   string
	Sum    []byte
}

Checksum for plugin binaries and archives. It contains the object name, os, arch, and the hash sum value.

Format in string: '<object>:<os>:<arch>:<base64-sha256-sum>'.

Example: 'archive:darwin:arm64:lgNgp5LO81yt1boBsiaNsJCzLWD9r5ovW+el5k/dDZ8='.

func (c Checksum) Compare(other Checksum) int

func (c Checksum) MarshalJSON() ([]byte, error)

func (c Checksum) MarshalText() ([]byte, error)

func (c Checksum) Match(list []Checksum) bool

func (c Checksum) String() string

func (c *Checksum) UnmarshalJSON(data []byte) error

func (c *Checksum) UnmarshalText(data []byte) error

type ConstraintMap ¶

type ConstraintMap map[Name]*semver.Constraints

ConstraintMap is a map of plugin names to version constraints.

func ParseConstraintMap(src map[string]string) (ConstraintMap, error)

type LocalSource ¶

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

LocalSource is a plugin source that looks up plugins from a local directory. The directory structure should be:

"<path>/<namespace>/<shortname>@<version>"

For example with the path ".fabric/plugins" plugin name "blackstork/sqlite" and version "1.0.0":

".fabric/plugins/blackstork/[email protected]"

File checksums can be provided in a file with the same name as the plugin binary but with a "_checksums.txt" suffix. The file should contain a list of checksums for all supported platforms.

func NewLocal(path string, logger *slog.Logger, tracer trace.Tracer) *LocalSource

func (source LocalSource) Lookup(ctx context.Context, name Name) (_ []Version, err error)

func (source LocalSource) Resolve(ctx context.Context, name Name, version Version, checksums []Checksum) (_ *ResolvedPlugin, err error)

type LockCheckResult ¶

type LockCheckResult struct {
	Missing  ConstraintMap
	Mismatch ConstraintMap
	Removed  map[Name]Version
}

LockCheckResult is the result of a lock check.

func (result LockCheckResult) IsInstallRequired() bool

type LockFile ¶

type LockFile struct {
	Plugins []PluginLock `json:"plugins"`
}

LockFile is a plugin lock configuration.

func ReadLockFile(r io.Reader) (*LockFile, error)

func ReadLockFileFrom(path string) (*LockFile, error)

func (file *LockFile) Check(constraints ConstraintMap) LockCheckResult

type Name ¶

type Name [2]string

Name of a plugin structured as '<namespace>/<name>'.

func ParseName(name string) (Name, error)

func (n Name) Compare(other Name) int

func (n Name) MarshalJSON() ([]byte, error)

func (n Name) Namespace() string

func (n Name) Short() string

func (n Name) String() string

func (n *Name) UnmarshalJSON(data []byte) error

type Option ¶

type Option func(*options)

Option is a functional option for the resolver.

func WithLogger(logger *slog.Logger) Option

func WithSources(sources ...Source) Option

func WithTracer(tracer trace.Tracer) Option

type PluginLock ¶

type PluginLock struct {
	Name      Name       `json:"name"`
	Version   Version    `json:"version"`
	Checksums []Checksum `json:"checksums"`
}

PluginLock is a lock for a one plugin.

type RemoteOptions ¶ added in v0.4.2

type RemoteOptions struct {
	// BaseURL is the base URL of the registry.
	BaseURL string
	// DownloadDir is the directory where the plugins are downloaded.
	DownloadDir string
	// UserAgent is the http user agent to use for the requests.
	// Useful for debugging and statistics on the registry side.
	UserAgent string
	// Tracer is the tracer to use for tracing.
	Tracer trace.Tracer
	// Logger is the logger to use for logging.
	Logger *slog.Logger
}

RemoteOptions represents the options for the remote source.

type RemoteSource ¶

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

RemoteSource is a plugin source that looks up plugins from a remote registry. The registry should implement the Fabric Registry API.

func NewRemote(options RemoteOptions) *RemoteSource

func (source RemoteSource) Lookup(ctx context.Context, name Name) (_ []Version, err error)

func (source RemoteSource) Resolve(ctx context.Context, name Name, version Version, checksums []Checksum) (_ *ResolvedPlugin, err error)

type ResolvedPlugin ¶

type ResolvedPlugin struct {
	// BinaryPath for the current platform.
	BinaryPath string
	// Checksums is a list of checksums for the plugin including all supported platforms.
	Checksums []Checksum
}

ResolvedPlugin contains the binary path and checksum for a plugin.

type Resolver ¶

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

Resolver resolves and installs plugins.

func NewResolver(constraints map[string]string, opts ...Option) (*Resolver, diagnostics.Diag)

func (r *Resolver) Install(ctx context.Context, lockFile *LockFile, upgrade bool) (_ *LockFile, diags diagnostics.Diag)

func (r *Resolver) Resolve(ctx context.Context, lockFile *LockFile) (_ map[string]string, diags diagnostics.Diag)

type Source ¶

type Source interface {
	// Lookup returns a list of available versions for the given plugin.
	Lookup(ctx context.Context, name Name) ([]Version, error)
	// Resolve returns the binary path and checksums for the given plugin version.
	Resolve(ctx context.Context, name Name, version Version, checksums []Checksum) (*ResolvedPlugin, error)
}

Source is the interface for plugin sources. A source is responsible for listing, looking up, and resolving plugins. The source may use a local directory, a registry, or any other source. If the source is unable to find a plugin, it should return ErrPluginNotFound.

type Version ¶

type Version struct {
	*semver.Version
}

Version is a version of a plugin. It is a wrapper around semver.Version with strict parsing.

func (v Version) Compare(other Version) int

func (v *Version) UnmarshalJSON(data []byte) error