Files
archie/internal/webui/api_extensions.go
T

317 lines
9.9 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"`
}
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)
}
}
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.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
}
var request installExtensionRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
http.Error(w, "invalid request body", http.StatusBadRequest)
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))
}
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
}
var request extensionEnabledRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
http.Error(w, "invalid request body", http.StatusBadRequest)
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.Warn("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))
}