Files
archie/internal/webui/api_extensions.go
T

406 lines
13 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"net/http"
"slices"
"strings"
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
)
type authorityView struct {
CredentialServices []string `json:"credential_services"`
EgressHosts []string `json:"egress_hosts"`
ForgePermissions []string `json:"forge_permissions"`
Triggers []string `json:"triggers"`
Tools []string `json:"tools"`
Env []string `json:"env"`
}
func authorityOf(a storepkg.Authority) authorityView {
return authorityView{
CredentialServices: orEmpty(a.CredentialServices), EgressHosts: orEmpty(a.EgressHosts),
ForgePermissions: orEmpty(a.ForgePermissions), Triggers: orEmpty(a.Triggers),
Tools: orEmpty(a.Tools), Env: orEmpty(a.Env),
}
}
func orEmpty(s []string) []string {
if s == nil {
return []string{}
}
return s
}
// ExtensionView is one installed package as the dashboard shows it: what it
// declares, what the operator accepted, and whether it is enabled.
type ExtensionView struct {
Name string `json:"name"`
DisplayName string `json:"display_name"`
Description string `json:"description"`
Version string `json:"version"`
Reference string `json:"reference"`
Digest string `json:"digest"`
Surfaces []string `json:"surfaces"`
Declared authorityView `json:"declared"`
Accepted *authorityView `json:"accepted"`
Enabled bool `json:"enabled"`
// Pending is an update waiting for approval, with only the grants it adds
// to what the operator accepted.
Pending *pendingView `json:"pending"`
CanRollback bool `json:"can_rollback"`
// UpdatePolicy is "manual" or "auto".
UpdatePolicy string `json:"update_policy"`
}
type pendingView struct {
Digest string `json:"digest"`
Added authorityView `json:"added"`
}
// addedGrants returns the grants want asks for that held does not grant.
func addedGrants(held *storepkg.Authority, want storepkg.Authority) authorityView {
var have storepkg.Authority
if held != nil {
have = *held
}
missing := func(have, want []string) []string {
return slices.DeleteFunc(slices.Clone(want), func(grant string) bool { return slices.Contains(have, grant) })
}
return authorityOf(storepkg.Authority{
CredentialServices: missing(have.CredentialServices, want.CredentialServices),
EgressHosts: missing(have.EgressHosts, want.EgressHosts),
ForgePermissions: missing(have.ForgePermissions, want.ForgePermissions),
Triggers: missing(have.Triggers, want.Triggers),
Tools: missing(have.Tools, want.Tools),
Env: missing(have.Env, want.Env),
})
}
func extensionView(p storepkg.Installed, enabled bool) ExtensionView {
view := ExtensionView{
Name: p.Name, DisplayName: p.Descriptor.DisplayName, Description: p.Descriptor.Description,
Version: p.Descriptor.Version, Reference: p.Reference, Digest: p.Digest,
Surfaces: []string{}, Declared: authorityOf(p.Descriptor.Authority), Enabled: enabled,
}
for _, extension := range p.Descriptor.Contributes.Extensions {
if !slices.Contains(view.Surfaces, extension.Surface) {
view.Surfaces = append(view.Surfaces, extension.Surface)
}
}
view.CanRollback = p.Previous != nil
view.UpdatePolicy = p.UpdatePolicy
if p.Pending != nil && p.PendingAuthority != nil {
view.Pending = &pendingView{Digest: p.Pending.Digest, Added: addedGrants(p.AcceptedAuthority, *p.PendingAuthority)}
}
if p.AcceptedAuthority != nil {
accepted := authorityOf(*p.AcceptedAuthority)
view.Accepted = &accepted
}
return view
}
// extensionSettings reads the extension-settings resource and the version a
// replacement must name.
func (s *Server) extensionSettings(ctx context.Context) (controlplanerpc.ExtensionSettings, int64, error) {
var doc controlplanerpc.ExtensionSettings
response, err := s.ControlPlane.Query(ctx, &controlpb.QueryRequest{Kind: controlplanerpc.ExtensionSettingsKind})
if err != nil {
return doc, 0, err
}
if response.Resource == nil {
return doc, 0, errors.New("extension settings missing")
}
if err := json.Unmarshal(response.Resource.ValueJson, &doc); err != nil {
return doc, 0, err
}
return doc, response.Resource.Version, nil
}
// putExtensionSettings replaces the extension-settings resource at version.
func (s *Server) putExtensionSettings(ctx context.Context, doc controlplanerpc.ExtensionSettings, version int64) error {
value, err := json.Marshal(doc)
if err != nil {
return err
}
audit, err := webAudit(ctx)
if err != nil {
return err
}
_, err = s.ControlPlane.Command(ctx, &controlpb.CommandRequest{
Kind: controlplanerpc.ExtensionSettingsKind, Command: "replace", ValueJson: value,
ExpectedVersion: version, Actor: string(audit.ActorID), Source: audit.Source, RequestId: audit.RequestID,
})
return err
}
// withExtension returns doc with the named extension set to enabled, or
// removed when enabled is nil.
func withExtension(doc controlplanerpc.ExtensionSettings, name string, enabled *bool) controlplanerpc.ExtensionSettings {
next := controlplanerpc.ExtensionSettings{}
found := false
for _, setting := range doc.Extensions {
if setting.Name != name {
next.Extensions = append(next.Extensions, setting)
continue
}
found = true
if enabled != nil {
setting.Enabled = *enabled
next.Extensions = append(next.Extensions, setting)
}
}
if !found && enabled != nil {
next.Extensions = append(next.Extensions, controlplanerpc.ExtensionSetting{Name: name, Enabled: *enabled})
}
return next
}
func (s *Server) extensionsReady(w http.ResponseWriter) bool {
if s.Packages == nil || s.ControlPlane == nil {
http.Error(w, "extensions unavailable", http.StatusServiceUnavailable)
return false
}
return true
}
func writePackageError(w http.ResponseWriter, err error) {
switch {
case errors.Is(err, storepkg.ErrNotFound):
http.Error(w, "extension not installed", http.StatusNotFound)
case errors.Is(err, storepkg.ErrNoPendingUpdate), errors.Is(err, storepkg.ErrNoPrevious), errors.Is(err, storepkg.ErrRequired):
http.Error(w, err.Error(), http.StatusConflict)
case errors.Is(err, storepkg.ErrInvalidPolicy):
http.Error(w, err.Error(), http.StatusBadRequest)
case errors.Is(err, storepkg.ErrInstalled):
http.Error(w, "extension already installed", http.StatusConflict)
default:
http.Error(w, err.Error(), http.StatusBadRequest)
}
}
// handleExtensions lists the installed packages with their authority and
// enabled state.
func (s *Server) handleExtensions(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
installed, err := s.Packages.ListInstalled(r.Context())
if err != nil {
writePackageError(w, err)
return
}
doc, _, err := s.extensionSettings(r.Context())
if err != nil {
writeControlPlaneError(w, err)
return
}
enabled := make(map[string]bool, len(doc.Extensions))
for _, setting := range doc.Extensions {
enabled[setting.Name] = setting.Enabled
}
views := make([]ExtensionView, 0, len(installed))
for _, p := range installed {
views = append(views, extensionView(p, enabled[p.Name]))
}
writeJSON(w, map[string]any{"extensions": views})
}
type installExtensionRequest struct {
Name string `json:"name"`
Reference string `json:"reference"`
Digest string `json:"digest"`
}
// handleExtensionInstall installs a digest-pinned package. It does not enable
// it and does not accept its authority: both are separate operator actions.
func (s *Server) handleExtensionInstall(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
request, ok := decodeBody[installExtensionRequest](w, r)
if !ok {
return
}
p, err := s.Packages.InstallPackage(r.Context(),
strings.TrimSpace(request.Name), strings.TrimSpace(request.Reference), strings.TrimSpace(request.Digest))
if err != nil {
writePackageError(w, err)
return
}
writeJSON(w, extensionView(p, false))
}
// handleExtensionAccept records the operator's acceptance of exactly the
// authority the package declares.
func (s *Server) handleExtensionAccept(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
name := r.PathValue("name")
installed, err := s.Packages.GetInstalled(r.Context(), name)
if err != nil {
writePackageError(w, err)
return
}
p, err := s.Packages.AcceptPackageAuthority(r.Context(), name, installed.Descriptor.Authority)
if err != nil {
writePackageError(w, err)
return
}
writeJSON(w, extensionView(p, false))
}
// handleExtensionUpdate moves a package to the catalogue's digest: an update
// that adds no authority applies, one that does waits as pending.
func (s *Server) handleExtensionUpdate(w http.ResponseWriter, r *http.Request) {
s.packageTransition(w, r, s.Packages.UpdatePackage)
}
// handleExtensionApproveUpdate applies the pending update and accepts the
// authority it declares.
func (s *Server) handleExtensionApproveUpdate(w http.ResponseWriter, r *http.Request) {
s.packageTransition(w, r, s.Packages.ApprovePackageUpdate)
}
// handleExtensionRollback restores the previous digest and its accepted
// authority.
func (s *Server) handleExtensionRollback(w http.ResponseWriter, r *http.Request) {
s.packageTransition(w, r, s.Packages.RollbackPackage)
}
type updatePolicyRequest struct {
Policy string `json:"policy"`
}
// handleExtensionUpdatePolicy sets whether the State Store updates a package
// on its own.
func (s *Server) handleExtensionUpdatePolicy(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
request, ok := decodeBody[updatePolicyRequest](w, r)
if !ok {
return
}
p, err := s.Packages.SetPackageUpdatePolicy(r.Context(), r.PathValue("name"), request.Policy)
if err != nil {
writePackageError(w, err)
return
}
writeJSON(w, extensionView(p, false))
}
func (s *Server) packageTransition(w http.ResponseWriter, r *http.Request, do func(context.Context, string) (storepkg.Installed, error)) {
if !s.extensionsReady(w) {
return
}
p, err := do(r.Context(), r.PathValue("name"))
if err != nil {
writePackageError(w, err)
return
}
writeJSON(w, extensionView(p, false))
}
type extensionEnabledRequest struct {
Enabled bool `json:"enabled"`
}
// handleExtensionEnabled enables or disables an installed extension.
func (s *Server) handleExtensionEnabled(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
request, ok := decodeBody[extensionEnabledRequest](w, r)
if !ok {
return
}
name := r.PathValue("name")
if _, err := s.Packages.GetInstalled(r.Context(), name); err != nil {
writePackageError(w, err)
return
}
doc, version, err := s.extensionSettings(r.Context())
if err != nil {
writeControlPlaneError(w, err)
return
}
if err := s.putExtensionSettings(r.Context(), withExtension(doc, name, &request.Enabled), version); err != nil {
writeControlPlaneError(w, err)
return
}
writeJSON(w, map[string]any{"name": name, "enabled": request.Enabled})
}
// handleExtensionRemove uninstalls an extension and drops its setting, so a
// later reinstall does not start enabled.
func (s *Server) handleExtensionRemove(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
name := r.PathValue("name")
if err := s.Packages.RemoveInstalled(r.Context(), name); err != nil {
writePackageError(w, err)
return
}
if doc, version, err := s.extensionSettings(r.Context()); err == nil {
if err := s.putExtensionSettings(r.Context(), withExtension(doc, name, nil), version); err != nil {
s.Log.WarnContext(r.Context(), "drop extension setting", "name", name, "err", err)
}
}
writeJSON(w, map[string]any{"name": name, "removed": true})
}
// catalogueView is one package the catalogue offers, marked when this org has
// it installed.
type catalogueView struct {
storepkg.CatalogueEntry
Installed bool `json:"installed"`
}
// handleCatalogue lists the packages the verified catalogue offers.
func (s *Server) handleCatalogue(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
catalogue, err := s.Packages.ListCatalogue(r.Context())
if err != nil {
http.Error(w, "catalogue unavailable: "+err.Error(), http.StatusBadGateway)
return
}
installed, err := s.Packages.ListInstalled(r.Context())
if err != nil {
writePackageError(w, err)
return
}
have := make(map[string]bool, len(installed))
for _, p := range installed {
have[p.Name] = true
}
out := make([]catalogueView, 0, len(catalogue.Packages))
for _, entry := range catalogue.Packages {
out = append(out, catalogueView{CatalogueEntry: entry, Installed: have[entry.Name]})
}
writeJSON(w, out)
}
// handleCatalogueInstall installs one catalogue package by name, at the digest
// the verified catalogue pins.
func (s *Server) handleCatalogueInstall(w http.ResponseWriter, r *http.Request) {
if !s.extensionsReady(w) {
return
}
p, err := s.Packages.InstallFromCatalogue(r.Context(), r.PathValue("name"))
if err != nil {
writePackageError(w, err)
return
}
writeJSON(w, extensionView(p, false))
}