317 lines
9.9 KiB
Go
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))
|
|
}
|