472 lines
14 KiB
Go
472 lines
14 KiB
Go
package webui
|
|
|
|
import (
|
|
"cmp"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
)
|
|
|
|
// orgsAPI owns the /api/orgs routes except selecting the current org, which
|
|
// sets a cookie and stays with the session code. memberIssuer is the provider
|
|
// the add-member route binds subjects under.
|
|
type orgsAPI struct {
|
|
orgs org.API
|
|
identities identity.Repository
|
|
subjects identity.SubjectBinding
|
|
memberIssuer func(*http.Request) string
|
|
}
|
|
|
|
func newOrgsAPI(s *Server) *orgsAPI {
|
|
return &orgsAPI{orgs: s.Orgs, identities: s.Identities, subjects: s.Subjects, memberIssuer: s.memberIssuer}
|
|
}
|
|
|
|
func (a *orgsAPI) register(mux *http.ServeMux) {
|
|
mux.HandleFunc("GET /api/orgs", a.handleOrgsList)
|
|
mux.HandleFunc("POST /api/orgs", a.handleOrgCreate)
|
|
mux.HandleFunc("GET /api/orgs/{id}", a.handleOrgGet)
|
|
mux.HandleFunc("GET /api/orgs/{id}/workspaces", a.handleOrgWorkspacesList)
|
|
mux.HandleFunc("POST /api/orgs/{id}/workspaces", a.handleOrgWorkspaceCreate)
|
|
mux.HandleFunc("GET /api/orgs/{id}/members", a.handleOrgMembersList)
|
|
mux.HandleFunc("POST /api/orgs/{id}/members", a.handleOrgMemberAdd)
|
|
mux.HandleFunc("PUT /api/orgs/{id}/members/{identity}", a.handleOrgMemberSet)
|
|
mux.HandleFunc("DELETE /api/orgs/{id}/members/{identity}", a.handleOrgMemberRemove)
|
|
mux.HandleFunc("GET /api/orgs/{id}/agents", a.handleOrgAgentsList)
|
|
mux.HandleFunc("PUT /api/orgs/{id}/agents/{identity}", instanceOnly(a.handleOrgAgentAssign))
|
|
}
|
|
|
|
// orgReady answers Unavailable when this process hosts no org store.
|
|
func (a *orgsAPI) orgReady(w http.ResponseWriter) bool {
|
|
if a.orgs == nil {
|
|
http.Error(w, "orgs unavailable", http.StatusServiceUnavailable)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// orgInPath resolves the route's {id}: the caller's own org, or any org for
|
|
// an instance admin. Another tenant reads as not found rather than leaking.
|
|
func (a *orgsAPI) orgInPath(w http.ResponseWriter, r *http.Request) (org.OrgID, bool) {
|
|
id := org.OrgID(r.PathValue("id"))
|
|
if id != policyOrg(r) && !instanceOwner(r) {
|
|
http.Error(w, "org not found", http.StatusNotFound)
|
|
return "", false
|
|
}
|
|
return id, true
|
|
}
|
|
|
|
// handleOrgsList lists every org to an instance admin and the caller's own
|
|
// and member orgs to anyone else, naming the org the caller acts in and the
|
|
// ones it may select.
|
|
func (a *orgsAPI) handleOrgsList(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
values, err := a.orgs.ListOrgs(r.Context())
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
caller, admin := policyOrg(r), instanceOwner(r)
|
|
principal, _ := access.PrincipalFromContext(r.Context())
|
|
out, member := []org.Org{}, []org.OrgID{}
|
|
for _, value := range values {
|
|
if value.ID == caller || admin || principal.Member(value.ID) {
|
|
out = append(out, value)
|
|
}
|
|
if value.ID == caller || principal.Member(value.ID) {
|
|
member = append(member, value.ID)
|
|
}
|
|
}
|
|
writeJSON(w, map[string]any{"orgs": out, "current": caller, "instance_admin": admin, "member_orgs": member})
|
|
}
|
|
|
|
// handleOrgCreate creates an org with its default workspace and first owner.
|
|
// Only an instance admin may.
|
|
func (a *orgsAPI) handleOrgCreate(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
if !instanceOwner(r) {
|
|
http.Error(w, "only an instance admin creates orgs", http.StatusForbidden)
|
|
return
|
|
}
|
|
creator, ok := a.orgs.(org.Creator)
|
|
if !ok {
|
|
http.Error(w, "org creation unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
var request struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
OwnerIdentity string `json:"owner_identity"`
|
|
}
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
|
|
http.Error(w, "invalid org: "+err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
created, err := creator.CreateOrg(r.Context(), org.Org{ID: org.OrgID(request.ID), Name: request.Name}, identity.IdentityID(request.OwnerIdentity))
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
writeJSON(w, map[string]any{"org": created})
|
|
}
|
|
|
|
func (a *orgsAPI) handleOrgGet(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
value, err := a.orgs.GetOrg(r.Context(), id)
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, map[string]any{"org": value})
|
|
}
|
|
|
|
func (a *orgsAPI) handleOrgWorkspacesList(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
values, err := a.orgs.ListWorkspaces(r.Context(), id)
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
if values == nil {
|
|
values = []org.Workspace{}
|
|
}
|
|
writeJSON(w, map[string]any{"workspaces": values})
|
|
}
|
|
|
|
func (a *orgsAPI) handleOrgWorkspaceCreate(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
Environment string `json:"environment"`
|
|
}
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
|
|
http.Error(w, "invalid workspace: "+err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
value, err := a.orgs.CreateWorkspace(r.Context(), org.Workspace{
|
|
ID: org.WorkspaceID(request.ID), OrgID: id, Name: request.Name, Environment: request.Environment,
|
|
})
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
writeJSON(w, map[string]any{"workspace": value})
|
|
}
|
|
|
|
func (a *orgsAPI) handleOrgMembersList(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
values, err := a.orgs.ListMembers(r.Context(), id)
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
if values == nil {
|
|
values = []org.Member{}
|
|
}
|
|
writeJSON(w, map[string]any{"members": values})
|
|
}
|
|
|
|
// handleOrgMemberSet grants or moves one identity's role in the caller's org,
|
|
// or in one workspace when the body names one.
|
|
func (a *orgsAPI) handleOrgMemberSet(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request struct {
|
|
Role string `json:"role"`
|
|
Workspace string `json:"workspace"`
|
|
}
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
|
|
http.Error(w, "invalid membership: "+err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
membership := org.Membership{
|
|
IdentityID: identity.IdentityID(r.PathValue("identity")),
|
|
OrgID: id,
|
|
WorkspaceID: org.WorkspaceID(request.Workspace),
|
|
Role: org.Role(request.Role),
|
|
}
|
|
if !a.mayChangeMembership(w, r, membership, membership.Role) {
|
|
return
|
|
}
|
|
if err := a.orgs.EnsureMembership(r.Context(), membership); err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, map[string]any{"membership": membership})
|
|
}
|
|
|
|
// handleOrgMemberAdd adds a person by the subject their provider asserts or by
|
|
// their email, creating the identity and binding it so that person's next
|
|
// sign-in resolves to it with this role. An already-bound subject keeps its
|
|
// identity and only gains the membership.
|
|
func (a *orgsAPI) handleOrgMemberAdd(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
if a.subjects == nil || a.identities == nil || a.memberIssuer(r) == "" {
|
|
http.Error(w, "adding a person needs a configured identity provider", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
request, bound, name, ok := a.decodeMemberAdd(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
existing, err := a.subjects.ResolveSubject(r.Context(), bound)
|
|
if err != nil && !errors.Is(err, identity.ErrNotFound) {
|
|
writeIdentityError(w, err)
|
|
return
|
|
}
|
|
unbound := err != nil
|
|
membership := org.Membership{
|
|
IdentityID: existing.ID, OrgID: id,
|
|
WorkspaceID: org.WorkspaceID(request.Workspace), Role: org.Role(request.Role),
|
|
}
|
|
if unbound {
|
|
if membership.IdentityID, err = randomIdentityID(); err != nil {
|
|
http.Error(w, "cannot create identity ID", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
if !a.mayChangeMembership(w, r, membership, membership.Role) {
|
|
return
|
|
}
|
|
if unbound && !a.createBoundIdentity(w, r, membership.IdentityID, name, bound) {
|
|
return
|
|
}
|
|
if err := a.orgs.EnsureMembership(r.Context(), membership); err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
writeJSON(w, map[string]any{"membership": membership})
|
|
}
|
|
|
|
type memberAddRequest struct {
|
|
Subject string `json:"subject"`
|
|
Email string `json:"email"`
|
|
DisplayName string `json:"display_name"`
|
|
Role string `json:"role"`
|
|
Workspace string `json:"workspace"`
|
|
}
|
|
|
|
// decodeMemberAdd reads and validates an add-member body, returning the
|
|
// provider subject it names and the display name to give a new identity. It
|
|
// has written the error when ok is false.
|
|
func (a *orgsAPI) decodeMemberAdd(w http.ResponseWriter, r *http.Request) (request memberAddRequest, bound identity.Subject, name string, ok bool) {
|
|
request, ok = decodeBody[memberAddRequest](w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
name = strings.TrimSpace(request.DisplayName)
|
|
subject, email := strings.TrimSpace(request.Subject), strings.TrimSpace(request.Email)
|
|
switch {
|
|
case (subject == "") == (email == ""):
|
|
http.Error(w, "give either a subject or an email", http.StatusBadRequest)
|
|
return request, bound, name, false
|
|
case subject != "":
|
|
bound, name = identity.Subject{Issuer: a.memberIssuer(r), Subject: subject}, cmp.Or(name, subject)
|
|
default:
|
|
bound, name = identity.EmailSubject(a.memberIssuer(r), email), cmp.Or(name, email)
|
|
}
|
|
if err := org.Role(request.Role).Validate(); err != nil {
|
|
writeOrgError(w, err)
|
|
return request, bound, name, false
|
|
}
|
|
return request, bound, name, true
|
|
}
|
|
|
|
// createBoundIdentity makes a user identity and binds subject to it, having
|
|
// written the error and returned false when either step fails.
|
|
func (a *orgsAPI) createBoundIdentity(w http.ResponseWriter, r *http.Request, id identity.IdentityID, name string, subject identity.Subject) bool {
|
|
audit, err := webAudit(r.Context())
|
|
if err != nil {
|
|
http.Error(w, "cannot create request ID", http.StatusInternalServerError)
|
|
return false
|
|
}
|
|
value, err := identity.New(id, identity.KindUser, name)
|
|
if err == nil {
|
|
_, err = a.identities.Create(r.Context(), value, audit)
|
|
}
|
|
if err == nil {
|
|
err = a.subjects.BindSubject(r.Context(), id, subject, audit)
|
|
}
|
|
if err != nil {
|
|
writeIdentityError(w, err)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (a *orgsAPI) handleOrgMemberRemove(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
membership := org.Membership{
|
|
IdentityID: identity.IdentityID(r.PathValue("identity")),
|
|
OrgID: id,
|
|
WorkspaceID: org.WorkspaceID(r.URL.Query().Get("workspace")),
|
|
}
|
|
if !a.mayChangeMembership(w, r, membership, "") {
|
|
return
|
|
}
|
|
if err := a.orgs.RemoveMembership(r.Context(), membership); err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (a *orgsAPI) handleOrgAgentAssign(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
err := a.orgs.AssignAgent(r.Context(), org.AgentAssignment{
|
|
IdentityID: identity.IdentityID(r.PathValue("identity")), OrgID: id,
|
|
})
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, map[string]any{"assigned": true})
|
|
}
|
|
|
|
// writeOrgError maps the org domain's errors, and their gRPC statuses, onto
|
|
// HTTP. The remote-client path keeps the status code through unmapError's
|
|
// wrapping, so writeControlPlaneError names the same code the store sent.
|
|
// mayChangeMembership refuses, having written the error, a change that grants
|
|
// the owner role or alters an owner's membership unless the caller is an owner
|
|
// of the org: member management is an admin's grant, and without this an
|
|
// admin could make themselves owner -- and an owner of org-sys owns the
|
|
// instance.
|
|
func (a *orgsAPI) mayChangeMembership(w http.ResponseWriter, r *http.Request, target org.Membership, grant org.Role) bool {
|
|
principal, ok := access.PrincipalFromContext(r.Context())
|
|
if !ok {
|
|
principal = access.SharedTokenOwner()
|
|
}
|
|
if principal.Role("") == org.RoleOwner {
|
|
return true
|
|
}
|
|
touchesOwner := grant == org.RoleOwner
|
|
if !touchesOwner {
|
|
members, err := a.orgs.ListMembers(r.Context(), target.OrgID)
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return false
|
|
}
|
|
for _, m := range members {
|
|
if m.IdentityID == target.IdentityID && m.WorkspaceID == target.WorkspaceID && m.Role == org.RoleOwner {
|
|
touchesOwner = true
|
|
}
|
|
}
|
|
}
|
|
if touchesOwner {
|
|
http.Error(w, "only an owner may grant or change the owner role", http.StatusForbidden)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func writeOrgError(w http.ResponseWriter, err error) {
|
|
switch {
|
|
case errors.Is(err, org.ErrInvalidRole), errors.Is(err, org.ErrInvalidOrg),
|
|
errors.Is(err, org.ErrInvalidMembership), errors.Is(err, org.ErrInvalidWorkspace),
|
|
errors.Is(err, org.ErrInvalidAssignment):
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
case errors.Is(err, org.ErrOrgNotFound):
|
|
http.Error(w, err.Error(), http.StatusNotFound)
|
|
case errors.Is(err, org.ErrOrgExists), errors.Is(err, org.ErrWorkspaceExists), errors.Is(err, org.ErrMembershipExists),
|
|
errors.Is(err, org.ErrLastOwner):
|
|
http.Error(w, err.Error(), http.StatusConflict)
|
|
default:
|
|
writeControlPlaneError(w, err)
|
|
}
|
|
}
|
|
|
|
func (a *orgsAPI) handleOrgAgentsList(w http.ResponseWriter, r *http.Request) {
|
|
if !a.orgReady(w) {
|
|
return
|
|
}
|
|
id, ok := a.orgInPath(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
reader, ok := a.orgs.(org.AgentAssignments)
|
|
if !ok {
|
|
http.Error(w, "agent assignments unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
values, err := reader.ListOrgAgents(r.Context(), id)
|
|
if err != nil {
|
|
writeOrgError(w, err)
|
|
return
|
|
}
|
|
agents := make([]identity.Identity, 0, len(values))
|
|
if a.identities == nil {
|
|
http.Error(w, "identity authority unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
for _, assignment := range values {
|
|
value, err := a.identities.Get(r.Context(), assignment.IdentityID)
|
|
if err != nil {
|
|
writeIdentityError(w, err)
|
|
return
|
|
}
|
|
if value.Kind.Agent() {
|
|
agents = append(agents, value)
|
|
}
|
|
}
|
|
writeJSON(w, map[string]any{"agents": agents})
|
|
}
|