Files
archie/internal/infrastructure/staterpc/orgs.go
T

276 lines
9.3 KiB
Go

package staterpc
import (
"context"
"errors"
"slices"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// errOrgsUnavailable reports that this process hosts no org store.
var errOrgsUnavailable = status.Error(codes.Unavailable, "org store unavailable")
// orgStatus maps the org domain's errors onto the wire, keeping the message
// that names the offending role, org or workspace.
func orgStatus(err error) error {
switch {
case errors.Is(err, org.ErrOrgNotFound):
return status.Error(codes.NotFound, err.Error())
case errors.Is(err, org.ErrOrgExists), errors.Is(err, org.ErrWorkspaceExists), errors.Is(err, org.ErrMembershipExists):
return status.Error(codes.Aborted, err.Error())
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):
return status.Error(codes.InvalidArgument, err.Error())
}
return mapError(err)
}
// orgErr logs and maps one org RPC's failure.
func (s *server) orgErr(rpc string, err error) error {
if err != nil {
s.deps.Log.Error("staterpc call failed", "rpc", rpc, "err", err)
}
return orgStatus(err)
}
func orgProto(o org.Org) *pb.Org { return &pb.Org{Id: string(o.ID), Name: o.Name} }
func orgValue(o *pb.Org) org.Org { return org.Org{ID: org.OrgID(o.GetId()), Name: o.GetName()} }
func workspaceProto(w org.Workspace) *pb.Workspace {
return &pb.Workspace{Id: string(w.ID), OrgId: string(w.OrgID), Name: w.Name, Environment: w.Environment}
}
func workspaceValue(w *pb.Workspace) org.Workspace {
return org.Workspace{
ID: org.WorkspaceID(w.GetId()), OrgID: org.OrgID(w.GetOrgId()),
Name: w.GetName(), Environment: w.GetEnvironment(),
}
}
func memberProto(m org.Member) *pb.Member {
return &pb.Member{
IdentityId: string(m.IdentityID), Kind: string(m.Kind), DisplayName: m.DisplayName,
WorkspaceId: string(m.WorkspaceID), Role: string(m.Role),
}
}
func (s *orgServer) ListOrgs(ctx context.Context, _ *pb.ListOrgsRequest) (*pb.ListOrgsResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
values, err := s.deps.Orgs.ListOrgs(ctx)
if err != nil {
return nil, s.orgErr("ListOrgs", err)
}
// Only an instance admin or an internal service sees every org; anyone
// else sees their own.
if !readsEveryOrg(ctx) {
caller := org.OrgFromContext(ctx)
values = slices.DeleteFunc(values, func(o org.Org) bool { return o.ID != caller })
}
out := make([]*pb.Org, len(values))
for i := range values {
out[i] = orgProto(values[i])
}
return &pb.ListOrgsResponse{Orgs: out}, nil
}
// readsEveryOrg reports whether ctx may read another org's directory: an
// instance admin, or an internal service acting for no one and confined to no
// org, such as the daemon ticking every org's schedules.
func readsEveryOrg(ctx context.Context) bool {
if p, ok := access.PrincipalFromContext(ctx); ok {
return p.InstanceAdmin()
}
_, scoped := org.Scope(ctx)
return !scoped
}
// orgFor is the org a request acts in: the caller's own, or the one it names
// when the caller is an instance admin. Anyone else naming another org still
// acts in their own, so the contract cannot reach another tenant.
func orgFor(ctx context.Context, requested string) org.OrgID {
caller := org.OrgFromContext(ctx)
if requested == "" || org.OrgID(requested) == caller {
return caller
}
if p, ok := access.PrincipalFromContext(ctx); ok && p.InstanceAdmin() {
return org.OrgID(requested)
}
return caller
}
func (s *orgServer) GetOrg(ctx context.Context, r *pb.GetOrgRequest) (*pb.GetOrgResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
value, err := s.deps.Orgs.GetOrg(ctx, orgFor(ctx, r.GetOrgId()))
if err != nil {
return nil, s.orgErr("GetOrg", err)
}
return &pb.GetOrgResponse{Org: orgProto(value)}, nil
}
func (s *orgServer) CreateOrg(ctx context.Context, r *pb.CreateOrgRequest) (*pb.CreateOrgResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
if p, ok := access.PrincipalFromContext(ctx); !ok || !p.InstanceAdmin() {
return nil, status.Error(codes.PermissionDenied, "only an instance admin creates orgs")
}
value, err := s.deps.Orgs.CreateOrg(ctx, orgValue(&pb.Org{Id: r.GetId(), Name: r.GetName()}), identity.IdentityID(r.GetOwnerIdentityId()))
if err != nil {
return nil, s.orgErr("CreateOrg", err)
}
// The new org's role policies are what let its owner act in it.
if s.deps.Policies != nil {
if err := s.deps.Policies.EnsureShippedOrgPolicies(ctx, value.ID); err != nil {
return nil, s.logErr("CreateOrg policies", err)
}
}
return &pb.CreateOrgResponse{Org: orgProto(value)}, nil
}
func (s *orgServer) ListWorkspaces(ctx context.Context, r *pb.ListWorkspacesRequest) (*pb.ListWorkspacesResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
values, err := s.deps.Orgs.ListWorkspaces(ctx, orgFor(ctx, r.GetOrgId()))
if err != nil {
return nil, s.orgErr("ListWorkspaces", err)
}
out := make([]*pb.Workspace, len(values))
for i := range values {
out[i] = workspaceProto(values[i])
}
return &pb.ListWorkspacesResponse{Workspaces: out}, nil
}
func (s *orgServer) CreateWorkspace(ctx context.Context, r *pb.CreateWorkspaceRequest) (*pb.CreateWorkspaceResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
value := workspaceValue(&pb.Workspace{Id: r.GetId(), OrgId: string(orgFor(ctx, r.GetOrgId())), Name: r.GetName(), Environment: r.GetEnvironment()})
created, err := s.deps.Orgs.CreateWorkspace(ctx, value)
if err != nil {
return nil, s.orgErr("CreateWorkspace", err)
}
return &pb.CreateWorkspaceResponse{Workspace: workspaceProto(created)}, nil
}
func (s *orgServer) ListMembers(ctx context.Context, r *pb.ListMembersRequest) (*pb.ListMembersResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
values, err := s.deps.Orgs.ListMembers(ctx, orgFor(ctx, r.GetOrgId()))
if err != nil {
return nil, s.orgErr("ListMembers", err)
}
out := make([]*pb.Member, len(values))
for i := range values {
out[i] = memberProto(values[i])
}
return &pb.ListMembersResponse{Members: out}, nil
}
func (s *orgServer) SetMembership(ctx context.Context, r *pb.SetMembershipRequest) (*pb.SetMembershipResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
err := s.deps.Orgs.EnsureMembership(ctx, org.Membership{
IdentityID: identity.IdentityID(r.GetIdentityId()),
OrgID: orgFor(ctx, r.GetOrgId()),
WorkspaceID: org.WorkspaceID(r.GetWorkspaceId()),
Role: org.Role(r.GetRole()),
})
if err != nil {
return nil, s.orgErr("SetMembership", err)
}
return &pb.SetMembershipResponse{}, nil
}
func (s *orgServer) RemoveMembership(ctx context.Context, r *pb.RemoveMembershipRequest) (*pb.RemoveMembershipResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
err := s.deps.Orgs.RemoveMembership(ctx, org.Membership{
IdentityID: identity.IdentityID(r.GetIdentityId()),
OrgID: orgFor(ctx, r.GetOrgId()),
WorkspaceID: org.WorkspaceID(r.GetWorkspaceId()),
})
if err != nil {
return nil, s.orgErr("RemoveMembership", err)
}
return &pb.RemoveMembershipResponse{}, nil
}
func (s *orgServer) AssignAgent(ctx context.Context, r *pb.AssignAgentRequest) (*pb.AssignAgentResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
err := s.deps.Orgs.AssignAgent(ctx, org.AgentAssignment{
IdentityID: identity.IdentityID(r.GetIdentityId()),
OrgID: orgFor(ctx, r.GetOrgId()),
})
if err != nil {
return nil, s.orgErr("AssignAgent", err)
}
return &pb.AssignAgentResponse{}, nil
}
func (s *orgServer) ListOrgAgents(ctx context.Context, r *pb.ListOrgAgentsRequest) (*pb.ListOrgAgentsResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
owner := orgFor(ctx, r.GetOrgId())
if r.GetOrgId() != "" && readsEveryOrg(ctx) {
owner = org.OrgID(r.GetOrgId())
}
values, err := s.deps.Orgs.ListOrgAgents(ctx, owner)
if err != nil {
return nil, s.orgErr("ListOrgAgents", err)
}
out := make([]*pb.AgentAssignment, len(values))
for i, value := range values {
out[i] = &pb.AgentAssignment{IdentityId: string(value.IdentityID), OrgId: string(value.OrgID)}
}
return &pb.ListOrgAgentsResponse{Agents: out}, nil
}
type orgServer struct {
pb.UnimplementedOrgServiceServer
*server
}
// CallerModels answers the aliases the calling principal's org may use.
func (s *orgServer) CallerModels(ctx context.Context, _ *pb.CallerModelsRequest) (*pb.CallerModelsResponse, error) {
if s.deps.OrgModels == nil {
return nil, status.Error(codes.Unavailable, "model aliases unavailable")
}
orgID := string(org.OrgFromContext(ctx))
aliases, _, err := s.deps.OrgModels(ctx, orgID)
if err != nil {
return nil, s.logErr("CallerModels", err)
}
return &pb.CallerModelsResponse{OrgId: orgID, Aliases: aliases}, nil
}
// CallerModels returns the calling principal's org and the aliases it may
// use.
func (c *Client) CallerModels(ctx context.Context) (string, map[string]string, error) {
r, err := c.org.CallerModels(ctx, &pb.CallerModelsRequest{})
if err != nil {
return "", nil, unmapError(err)
}
return r.OrgId, r.Aliases, nil
}