Let a person belong to many places, or to none
A person was in exactly one project, chosen at approval, and could not use the gateway before that. People belong to several teams and to none, so: - memberships: a person is a member of any number of organizations, teams and projects, or of none; a member of a team or organization may use every project in it. users join/leave, and the people page adds and takes out from either side. Approval no longer needs a project. - personal keys: a key may have an owner and no project. /profile asks what a new key spends against; keys create --for does the same. auth.personal sets default limits for personal use or turns it off. - limits for people: --scope user holds a person across every key, project and the chat page; --per-member on an org, team or project gives each member their own share there. Resolution folds the tree, each per-member limit for the key's owner, and the owner's own, each in its own pool; the quotas page shows and sets both. - the chat page asks what to spend against and checks it per message. - usage records who spent it, so a person's budget survives a restart, personal use and chat included; restore no longer drops rows with no project. Leaving a project revokes the keys made there unless another membership still reaches it. A personal key keeps no threads or notes, which are per project, and is refused rather than dropped into the anonymous pool. Migration 0010 turns each person's project into a membership, adds usage.user_id and backfills it, and makes api_keys.project_id nullable. SQLite cannot drop NOT NULL, so the table is rebuilt; that needs foreign keys off, which only works outside a transaction, so migrations marked for it run on one connection with foreign_key_check before commit. Tested on a populated SQLite store with claims, and on a copy of the cluster's PostgreSQL store: 5 people became members, 17 keys and 3 claims intact, 145 of 577 usage rows and all 69 chat rows attributed. The PostgreSQL store tests, including new membership cases, pass on 16. users move is gone; join and leave replace it. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
1 parent
429c05a319
commit
098886e0e4
46 files changed
+2372
-468
No files matched your search
@@ -21,6 +21,37 @@ APIs change between minors without a deprecation period.
|
||||
|
||||
## Unreleased
|
||||
|
||||
### People belong to many places, or to none
|
||||
|
||||
A person was in exactly one project, chosen at approval, and could not use the
|
||||
gateway before that. Now:
|
||||
|
||||
- **Memberships.** A person can be a member of any number of organizations,
|
||||
teams and projects, or of none. A member of a team or organization may use
|
||||
every project in it. `llmgw users join/leave`, and the people page adds and
|
||||
removes them from either side. Approving no longer requires a project.
|
||||
- **Personal keys.** A key can belong to a person with no project. On
|
||||
`/profile` a person chooses what a new key spends against: one of their
|
||||
projects, or Personal. `llmgw keys create --for <person>` does the same.
|
||||
`auth.personal` sets default limits for personal use, or turns it off.
|
||||
- **Limits for people.** `--scope user` limits a person across every key,
|
||||
project and the chat page. `--per-member` on an organization, team or
|
||||
project gives each member their own share there. Both are on the quotas
|
||||
page, and are enforced alongside the tree, each in its own pool.
|
||||
- **The chat page** asks what to spend against when a person has more than one
|
||||
choice, and checks it on every message.
|
||||
- **Spend is recorded with who spent it**, so a person's budget survives a
|
||||
restart, personal use and the chat page included.
|
||||
|
||||
Leaving a project revokes the keys the person made there, unless another
|
||||
membership still reaches it. A personal key keeps no conversations or notes:
|
||||
those are kept per project.
|
||||
|
||||
**Upgrading.** Migration 0010 turns everyone's project into a membership and
|
||||
attributes past usage to people where a key had an owner. On SQLite it rebuilds
|
||||
the keys table; it was run against a copy of a production PostgreSQL store
|
||||
before release. `llmgw users move` is gone: use `join` and `leave`.
|
||||
|
||||
### One menu on every page
|
||||
|
||||
Each page drew its own menu, and no two agreed: different links, in a different
|
||||
|
||||
+67
-12
@@ -39,10 +39,11 @@ The landing page then links to it, and the rest is:
|
||||
|
||||
```
|
||||
llmgw users list --pending --store …
|
||||
ID EMAIL NAME STATE PROJECT SIGNED UP
|
||||
usr-k4mq… ayse@example.com Ayşe pending - 4m12s ago
|
||||
ID EMAIL STATE ADMIN MEMBER OF SIGNED UP
|
||||
usr-k4mq… ayse@example.com pending - on their own 4m12s ago
|
||||
|
||||
llmgw users approve usr-k4mq… --project default --by ilker --store …
|
||||
llmgw users approve ayse@example.com --by ilker --store …
|
||||
llmgw users approve ayse@example.com --project Acme/ml/training --store … # or straight into a project
|
||||
```
|
||||
|
||||
That is the whole operator loop. From then on they sign in at `/login`, and
|
||||
@@ -105,15 +106,53 @@ The tree is not fixed once made:
|
||||
llmgw org rename project Acme/platform/gateway api-gateway
|
||||
llmgw org move project Acme/platform/gateway --to Scania/ml
|
||||
llmgw org remove team Acme/old # only when nothing is in it
|
||||
llmgw users move ayse@example.com --project Acme/ml/research
|
||||
llmgw users delete ayse@example.com --yes # signs out, revokes their keys
|
||||
llmgw keys list --all # every key, its project and owner
|
||||
llmgw keys list --all # every key, where it spends, and whose
|
||||
```
|
||||
|
||||
Moving a person takes the keys they made with them, so they stop spending the
|
||||
old project's budget; keys an operator issued in the project stay with it. A
|
||||
project that ever had a key cannot be removed, because usage history refers to
|
||||
it — rename it instead.
|
||||
A project that ever had a key cannot be removed, because usage history refers
|
||||
to it — rename it instead.
|
||||
|
||||
### Where people belong
|
||||
|
||||
A person can be a member of any number of organizations, teams and projects, or
|
||||
of none:
|
||||
|
||||
```
|
||||
llmgw users join ayse@example.com --team Acme/ml # every project in ml
|
||||
llmgw users join ayse@example.com --project Scania/research/vision
|
||||
llmgw users leave ayse@example.com --project Acme/ml/training
|
||||
```
|
||||
|
||||
A member of a team or organization may use every project in it. Leaving revokes
|
||||
the keys the person made in projects they can no longer reach; a project they
|
||||
still reach through another membership keeps them.
|
||||
|
||||
Someone who is a member of nothing still uses the gateway, on their own:
|
||||
personal keys, and the chat page, within their personal limits. When they make
|
||||
a key on `/profile` they choose what it spends against — one of their projects,
|
||||
or "Personal". An operator can do the same:
|
||||
|
||||
```
|
||||
llmgw keys create laptop --for ayse@example.com # personal
|
||||
llmgw keys create ci --for ayse@example.com --project Acme/ml/training
|
||||
```
|
||||
|
||||
Personal use can be limited by default, or turned off so people use the gateway
|
||||
only through their projects:
|
||||
|
||||
```yaml
|
||||
auth:
|
||||
personal:
|
||||
rpm: 20
|
||||
tpm: 50000
|
||||
budget: 10 # whole units
|
||||
period: month
|
||||
# disabled: true
|
||||
```
|
||||
|
||||
A personal key has no project, so it keeps no conversations or agent notes;
|
||||
those are kept per project.
|
||||
|
||||
`llmgw keys init` still works for provisioning scripts and is idempotent, but it
|
||||
will no longer move a team or project that already exists under another parent;
|
||||
@@ -195,6 +234,20 @@ llmgw keys limits --store … --scope project --id Acme/platform/gateway \
|
||||
--budget 50 --period month # 50 units a month
|
||||
```
|
||||
|
||||
Two more kinds of limit follow people rather than the tree:
|
||||
|
||||
```
|
||||
# A person, everywhere: every key they hold, every project, the chat page
|
||||
llmgw keys limits --scope user --id ayse@example.com --budget 25
|
||||
|
||||
# Each member of a project separately — a fair share, not one shared pool
|
||||
llmgw keys limits --scope project --id Acme/ml/training --per-member --rpm 20
|
||||
```
|
||||
|
||||
A request is held to all of them at once: the key's own, its project's, team's
|
||||
and organization's, each per-member limit on those for its owner, and the
|
||||
owner's own. The strictest wins, and each is counted in its own pool.
|
||||
|
||||
## The landing page
|
||||
|
||||
Someone who reaches the gateway without a key sees the landing page. Tell it who
|
||||
@@ -314,9 +367,11 @@ page exists.
|
||||
## Managing accounts from the browser
|
||||
|
||||
`/admin/users` is the tree: organizations, teams and projects, each project
|
||||
opening onto its people and its keys. From there an admin approves, moves,
|
||||
suspends and removes people, revokes keys, and adds, renames, moves and removes
|
||||
organizations, teams and projects. A searchable list of every account is at the
|
||||
opening onto its members and its keys. From there an admin approves people
|
||||
(into a project or on their own), adds them to and takes them out of
|
||||
organizations, teams and projects, suspends and removes them, revokes keys, and
|
||||
adds, renames, moves and removes organizations, teams and projects. `/admin/quotas`
|
||||
sets limits on the tree, per member of any part of it, and per person. A searchable list of every account is at the
|
||||
bottom. The page works as plain forms; with scripts on, a change updates it in
|
||||
place and the projects you had open stay open.
|
||||
|
||||
|
||||
@@ -29,6 +29,7 @@ rather than repeated.
|
||||
| `default_rpm` | `int` | [Auth](#auth) |
|
||||
| `default_tpm` | `int` | [Auth](#auth) |
|
||||
| `signup_open` | `bool` | [Auth](#auth) |
|
||||
| `personal` | `Personal` | [Auth](#auth) |
|
||||
| `pricing` | `map[string]Price` | [Auth](#auth) |
|
||||
| `default_price` | `Price` | [Auth](#auth) |
|
||||
| `flush_interval` | `time.Duration` | [Auth](#auth) |
|
||||
@@ -102,6 +103,11 @@ rather than repeated.
|
||||
| `ib_root` | `string` | [Options](#options) |
|
||||
| `prefer_nvml` | `bool` | [Options](#options) |
|
||||
| `skip_gpus` | `bool` | [Options](#options) |
|
||||
| `disabled` | `bool` | [Personal](#personal) |
|
||||
| `rpm` | `int` | [Personal](#personal) |
|
||||
| `tpm` | `int` | [Personal](#personal) |
|
||||
| `budget` | `float64` | [Personal](#personal) |
|
||||
| `period` | `string` | [Personal](#personal) |
|
||||
| `enabled` | `bool` | [Prefix](#prefix) |
|
||||
| `max_nodes` | `int` | [Prefix](#prefix) |
|
||||
| `min_match` | `int` | [Prefix](#prefix) |
|
||||
@@ -267,6 +273,15 @@ SignupOpen serves the signup form. Accounts it creates are pending until
|
||||
an operator approves them, so this is not a way in — but turning it off
|
||||
means accounts are made with `llmgw users create` instead.
|
||||
|
||||
### `personal`
|
||||
|
||||
`Personal`
|
||||
|
||||
Personal is what a person may do on their own, outside any project: make
|
||||
personal keys and use the chat page personally, within these limits.
|
||||
|
||||
Takes a [Personal](#personal) block.
|
||||
|
||||
### `pricing`
|
||||
|
||||
`map[string]Price`
|
||||
@@ -788,6 +803,33 @@ source of NVLink topology.
|
||||
SkipGPUs omits GPU discovery. A node without nvidia-smi is already
|
||||
found to have none, so this is for one whose driver is broken.
|
||||
|
||||
## Personal
|
||||
|
||||
### `disabled`
|
||||
|
||||
`bool`
|
||||
|
||||
Disabled refuses personal keys and personal chat; people then use the
|
||||
gateway only through projects they are members of.
|
||||
|
||||
### `rpm`
|
||||
|
||||
`int`
|
||||
|
||||
### `tpm`
|
||||
|
||||
`int`
|
||||
|
||||
### `budget`
|
||||
|
||||
`float64`
|
||||
|
||||
Budget is in whole units per Period ("day" or "month").
|
||||
|
||||
### `period`
|
||||
|
||||
`string`
|
||||
|
||||
## Prefix
|
||||
|
||||
### `enabled`
|
||||
|
||||
@@ -99,17 +99,21 @@ func TestApprovalIsWhatMakesAnAccountWork(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got.ProjectID != "proj" {
|
||||
t.Errorf("the approved account landed in project %q", got.ProjectID)
|
||||
if ok, err := st.CanUseProject(ctx, got.ID, "proj"); err != nil || !ok {
|
||||
t.Errorf("the approved account is not a member of the project it was approved into: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApprovalNeedsAProject(t *testing.T) {
|
||||
// An approved account with nowhere to put its keys passes every check and
|
||||
// then fails at the first key it tries to make.
|
||||
_, st := newStoreAndUser(t)
|
||||
if err := st.ApproveUser(context.Background(), "usr-1", "", "ilker", time.Now()); err == nil {
|
||||
t.Error("an account was approved into no project")
|
||||
func TestApprovalNeedNotNameAProject(t *testing.T) {
|
||||
// A person need not belong to anything to use the gateway: approved into
|
||||
// nothing, they work on their own within their personal limits.
|
||||
svc, st := newStoreAndUser(t)
|
||||
ctx := context.Background()
|
||||
if err := st.ApproveUser(ctx, "usr-1", "", "ilker", time.Now()); err != nil {
|
||||
t.Fatalf("approving with no project: %v", err)
|
||||
}
|
||||
if _, _, err := svc.SignIn(ctx, "ayse@example.com", goodPassword); err != nil {
|
||||
t.Errorf("an account approved into nothing cannot sign in: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.mynodes.xyz/ilker/llmgw/internal/auth"
|
||||
@@ -79,14 +80,27 @@ func (a *Accountant) RestoreBudgets(ctx context.Context, s store.Store, period s
|
||||
// totals would bring the control plane back up believing the team had spent
|
||||
// nothing — which is a budget that resets on every restart, for exactly the
|
||||
// scopes where it matters most.
|
||||
spend := make(map[string]int64, len(rows)*4)
|
||||
// And every pool a person is in: their own, and each per-member limit of
|
||||
// the project, team and organization they spent it in.
|
||||
spend := make(map[string]int64, len(rows)*8)
|
||||
for _, r := range rows {
|
||||
for _, o := range []store.LimitOwner{
|
||||
owners := []store.LimitOwner{
|
||||
{Scope: store.ScopeKey, ID: r.KeyID},
|
||||
{Scope: store.ScopeProject, ID: r.ProjectID},
|
||||
{Scope: store.ScopeTeam, ID: r.TeamID},
|
||||
{Scope: store.ScopeOrg, ID: r.OrgID},
|
||||
} {
|
||||
{Scope: store.ScopeUser, ID: r.UserID},
|
||||
}
|
||||
if r.UserID != "" && r.ProjectID != "" {
|
||||
owners = append(owners,
|
||||
store.MemberOwner(store.ScopeProjectMember, r.ProjectID, r.UserID),
|
||||
store.MemberOwner(store.ScopeTeamMember, r.TeamID, r.UserID),
|
||||
store.MemberOwner(store.ScopeOrgMember, r.OrgID, r.UserID))
|
||||
}
|
||||
for _, o := range owners {
|
||||
if o.ID == "" || strings.HasPrefix(o.ID, "/") {
|
||||
continue
|
||||
}
|
||||
if k := o.CounterKey(); k != "" {
|
||||
spend[k] += r.Micros
|
||||
}
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
package accounting
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"log/slog"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.mynodes.xyz/ilker/llmgw/internal/auth"
|
||||
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
|
||||
)
|
||||
|
||||
// peopleStore has Acme/ml/training with two members, ayse and deniz.
|
||||
func peopleStore(t *testing.T) (*store.DB, string) {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
s, err := store.OpenSQLite(ctx, filepath.Join(t.TempDir(), "p.db"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = s.Close() })
|
||||
org, _ := s.CreateOrg(ctx, "Acme")
|
||||
team, _ := s.CreateTeam(ctx, org, "ml")
|
||||
proj, _ := s.CreateProject(ctx, team, "training")
|
||||
for _, id := range []string{"ayse", "deniz"} {
|
||||
if err := s.CreateUser(ctx, store.User{ID: id, Email: id + "@x", Name: id,
|
||||
PasswordHash: "h", State: store.UserPending, CreatedAt: time.Now()}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.ApproveUser(ctx, id, proj, "test", time.Now()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
return s, proj
|
||||
}
|
||||
|
||||
// keyFor makes a key for a person and resolves it the way authentication does.
|
||||
func keyFor(t *testing.T, s *store.DB, id, user, project string) auth.Principal {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
_, k, _ := store.NewKey(id, id, project)
|
||||
if err := s.CreateUserKey(ctx, user, k); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
e, err := s.Resolve(ctx, id)
|
||||
if err != nil {
|
||||
t.Fatalf("resolving %s: %v", id, err)
|
||||
}
|
||||
return auth.Principal{KeyID: id, UserID: e.UserID, ProjectID: e.ProjectID, Limits: e}
|
||||
}
|
||||
|
||||
func TestAPersonsLimitIsOnePoolAcrossTheirKeys(t *testing.T) {
|
||||
s, proj := peopleStore(t)
|
||||
if err := s.PutLimits(context.Background(),
|
||||
store.Limits{Scope: store.ScopeUser, ScopeID: "ayse", RPM: intp(2)}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
a := New(pricing(t), nil, slog.New(slog.DiscardHandler))
|
||||
personal := keyFor(t, s, "k-personal", "ayse", "")
|
||||
inProject := keyFor(t, s, "k-project", "ayse", proj)
|
||||
|
||||
// Two requests, one on each key, use up the person's two a minute.
|
||||
for _, p := range []auth.Principal{personal, inProject} {
|
||||
if _, err := a.Check(p, "free", 1); err != nil {
|
||||
t.Fatalf("%s: %v", p.KeyID, err)
|
||||
}
|
||||
}
|
||||
if _, err := a.Check(personal, "free", 1); !errors.Is(err, ErrRateLimited) {
|
||||
t.Errorf("a third request across her keys was allowed: %v", err)
|
||||
}
|
||||
// Deniz is somebody else.
|
||||
if _, err := a.Check(keyFor(t, s, "k-deniz", "deniz", proj), "free", 1); err != nil {
|
||||
t.Errorf("another person was limited by hers: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPerMemberLimitCountsEachMemberApart(t *testing.T) {
|
||||
s, proj := peopleStore(t)
|
||||
if err := s.PutLimits(context.Background(),
|
||||
store.Limits{Scope: store.ScopeProjectMember, ScopeID: proj, RPM: intp(1)}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
a := New(pricing(t), nil, slog.New(slog.DiscardHandler))
|
||||
ayse := keyFor(t, s, "k-a", "ayse", proj)
|
||||
deniz := keyFor(t, s, "k-d", "deniz", proj)
|
||||
|
||||
if _, err := a.Check(ayse, "free", 1); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := a.Check(ayse, "free", 1); !errors.Is(err, ErrRateLimited) {
|
||||
t.Errorf("her second request passed a one-a-minute per-member limit: %v", err)
|
||||
}
|
||||
// Her share is hers: Deniz still has his.
|
||||
if _, err := a.Check(deniz, "free", 1); err != nil {
|
||||
t.Errorf("one member's use counted against another: %v", err)
|
||||
}
|
||||
// And outside the project it does not apply at all.
|
||||
if _, err := a.Check(keyFor(t, s, "k-a-own", "ayse", ""), "free", 1); err != nil {
|
||||
t.Errorf("a project's per-member limit held her personal key: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPersonsBudgetSurvivesARestart(t *testing.T) {
|
||||
s, _ := peopleStore(t)
|
||||
ctx := context.Background()
|
||||
if err := s.PutLimits(ctx, store.Limits{Scope: store.ScopeUser, ScopeID: "ayse",
|
||||
Budget: i64p(1000), BudgetPeriod: store.PeriodMonth}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Spent before the restart, personally and on the chat page.
|
||||
if err := s.WriteUsage(ctx, []store.Usage{
|
||||
{At: time.Now(), KeyID: "k-old", UserID: "ayse", CostMicros: 600, Model: "paid", ServedModel: "paid"},
|
||||
{At: time.Now(), KeyID: "session:ayse", UserID: "ayse", CostMicros: 500, Model: "paid", ServedModel: "paid"},
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
a := New(pricing(t), nil, slog.New(slog.DiscardHandler))
|
||||
if err := a.RestoreBudgets(ctx, s, store.PeriodMonth); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := a.Check(keyFor(t, s, "k-new", "ayse", ""), "paid", 1); !errors.Is(err, ErrBudgetSpent) {
|
||||
t.Errorf("a restart forgot what she had spent: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,9 @@ import (
|
||||
type Principal struct {
|
||||
KeyID string
|
||||
KeyPrefix string
|
||||
// UserID is the person the key belongs to, empty for a key an operator
|
||||
// issued in a project. A personal key has a person and no project.
|
||||
UserID string
|
||||
ProjectID string
|
||||
TeamID string
|
||||
OrgID string
|
||||
@@ -186,7 +189,7 @@ func (a *Authenticator) resolve(ctx context.Context, hash []byte) (Principal, er
|
||||
return Principal{}, err
|
||||
}
|
||||
return Principal{
|
||||
KeyID: k.ID, KeyPrefix: k.Prefix, ProjectID: eff.ProjectID,
|
||||
KeyID: k.ID, KeyPrefix: k.Prefix, UserID: eff.UserID, ProjectID: eff.ProjectID,
|
||||
TeamID: eff.TeamID, OrgID: eff.OrgID,
|
||||
Band: eff.Band, RoutingProfile: eff.RoutingProfile,
|
||||
Limits: eff,
|
||||
|
||||
+53
-10
@@ -85,7 +85,7 @@ func newKeyInitCmd(open opener) *cobra.Command {
|
||||
}
|
||||
|
||||
func newKeyCreateCmd(open opener) *cobra.Command {
|
||||
var project, band, profile, baseURL string
|
||||
var project, band, profile, baseURL, forUser string
|
||||
var expires, claimTTL time.Duration
|
||||
var claim bool
|
||||
|
||||
@@ -108,9 +108,22 @@ func newKeyCreateCmd(open opener) *cobra.Command {
|
||||
}
|
||||
defer s.Close()
|
||||
|
||||
p, err := resolveProject(cmd.Context(), s, project)
|
||||
if err != nil {
|
||||
return err
|
||||
// Three kinds: an operator's key in a project, a person's key in a
|
||||
// project they are a member of, and a person's personal key.
|
||||
var owner store.User
|
||||
if forUser != "" {
|
||||
if owner, err = resolveUser(cmd.Context(), s, forUser); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
var p store.ProjectPath
|
||||
if project != "" || forUser == "" {
|
||||
if p, err = resolveProject(cmd.Context(), s, project); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if p.ID == "" {
|
||||
p.Path = "personal, " + owner.Email
|
||||
}
|
||||
secret, k, err := store.NewKey(randomID("key"), args[0], p.ID)
|
||||
if err != nil {
|
||||
@@ -121,7 +134,15 @@ func newKeyCreateCmd(open opener) *cobra.Command {
|
||||
if expires > 0 {
|
||||
k.ExpiresAt = k.CreatedAt.Add(expires)
|
||||
}
|
||||
if err := s.CreateKey(cmd.Context(), k); err != nil {
|
||||
if owner.ID != "" {
|
||||
err = s.CreateUserKey(cmd.Context(), owner.ID, k)
|
||||
} else {
|
||||
err = s.CreateKey(cmd.Context(), k)
|
||||
}
|
||||
if errors.Is(err, store.ErrNotMember) {
|
||||
return fmt.Errorf("%s is not a member of %s; `llmgw users join` first", owner.Email, p.Path)
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("creating the key in %s: %w", p.Path, err)
|
||||
}
|
||||
|
||||
@@ -161,6 +182,8 @@ func newKeyCreateCmd(open opener) *cobra.Command {
|
||||
}
|
||||
cmd.Flags().StringVar(&project, "project", "",
|
||||
"project the key belongs to: id, path (Acme/platform/gateway) or unique name")
|
||||
cmd.Flags().StringVar(&forUser, "for", "",
|
||||
"a person the key belongs to (id or email); without --project it is their personal key")
|
||||
cmd.Flags().StringVar(&band, "band", "", "admission band; empty inherits")
|
||||
cmd.Flags().StringVar(&profile, "profile", "", "routing profile; empty inherits")
|
||||
cmd.Flags().DurationVar(&expires, "expires-in", 0, "lifetime; 0 never expires")
|
||||
@@ -200,8 +223,12 @@ func newKeyListCmd(open opener) *cobra.Command {
|
||||
fmt.Fprintln(w, "ID\tNAME\tKEY\tPROJECT\tOWNER\tSTATE\tLAST USED")
|
||||
now := time.Now()
|
||||
for _, r := range rows {
|
||||
where := r.ProjectPath
|
||||
if where == "" {
|
||||
where = "personal"
|
||||
}
|
||||
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", r.ID, r.Name, r.Prefix,
|
||||
r.ProjectPath, dash(r.OwnerEmail), keyState(r.Key, now), ago(r.LastUsedAt, now))
|
||||
where, dash(r.OwnerEmail), keyState(r.Key, now), ago(r.LastUsedAt, now))
|
||||
}
|
||||
return w.Flush()
|
||||
}
|
||||
@@ -260,6 +287,7 @@ func newKeyRevokeCmd(open opener) *cobra.Command {
|
||||
|
||||
func newLimitsCmd(open opener) *cobra.Command {
|
||||
var scope, id, period string
|
||||
var perMember bool
|
||||
var rpm, tpm int
|
||||
var budget float64
|
||||
var models []string
|
||||
@@ -298,14 +326,27 @@ func newLimitsCmd(open opener) *cobra.Command {
|
||||
return err
|
||||
}
|
||||
scopeID = p.ID
|
||||
case store.ScopeUser:
|
||||
u, err := resolveUser(cmd.Context(), s, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
scopeID = u.ID
|
||||
case store.ScopeKey:
|
||||
if id == "" {
|
||||
return errors.New("--scope key needs --id, the key's id")
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("--scope is org, team, project or key, not %q", scope)
|
||||
return fmt.Errorf("--scope is org, team, project, user or key, not %q", scope)
|
||||
}
|
||||
l := store.Limits{Scope: store.Scope(scope), ScopeID: scopeID}
|
||||
level := store.Scope(scope)
|
||||
if perMember {
|
||||
// Written on the scope, applied to each member separately.
|
||||
if level = store.MemberScope(level); level == "" {
|
||||
return errors.New("--per-member is for --scope org, team or project")
|
||||
}
|
||||
}
|
||||
l := store.Limits{Scope: level, ScopeID: scopeID}
|
||||
if cmd.Flags().Changed("rpm") {
|
||||
l.RPM = &rpm
|
||||
}
|
||||
@@ -330,11 +371,13 @@ func newLimitsCmd(open opener) *cobra.Command {
|
||||
if err := s.PutLimits(cmd.Context(), l); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "limits set on %s %s\n", scope, scopeID)
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "limits set on %s %s\n", level, scopeID)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&scope, "scope", "project", "org | team | project | key")
|
||||
cmd.Flags().StringVar(&scope, "scope", "project", "org | team | project | user | key")
|
||||
cmd.Flags().BoolVar(&perMember, "per-member", false,
|
||||
"with org, team or project: a limit for each member there, not one shared by all")
|
||||
cmd.Flags().StringVar(&id, "id", "", "which one: id, path or unique name (a key's id for --scope key)")
|
||||
cmd.Flags().IntVar(&rpm, "rpm", 0, "requests per minute")
|
||||
cmd.Flags().IntVar(&tpm, "tpm", 0, "tokens per minute")
|
||||
|
||||
+45
-18
@@ -46,21 +46,40 @@ func newOrgTreeCmd(open dbOpener) *cobra.Command {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var byProject map[string][]store.User
|
||||
var members map[string][]string
|
||||
var alone []store.User
|
||||
if people {
|
||||
users, err := s.Users(cmd.Context(), "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
byProject = map[string][]store.User{}
|
||||
all, err := s.AllMemberships(cmd.Context())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
email := map[string]string{}
|
||||
for _, u := range users {
|
||||
byProject[u.ProjectID] = append(byProject[u.ProjectID], u)
|
||||
email[u.ID] = u.Email + " " + string(u.State)
|
||||
if u.IsAdmin {
|
||||
email[u.ID] += " admin"
|
||||
}
|
||||
}
|
||||
members = map[string][]string{}
|
||||
in := map[string]bool{}
|
||||
for _, m := range all {
|
||||
members[string(m.Scope)+":"+m.ScopeID] = append(members[string(m.Scope)+":"+m.ScopeID], email[m.UserID])
|
||||
in[m.UserID] = true
|
||||
}
|
||||
for _, u := range users {
|
||||
if !in[u.ID] {
|
||||
alone = append(alone, u)
|
||||
}
|
||||
}
|
||||
}
|
||||
printTree(cmd.OutOrStdout(), tree, byProject)
|
||||
if people && len(byProject[""]) > 0 {
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "\nwaiting for approval\n")
|
||||
for _, u := range byProject[""] {
|
||||
printTree(cmd.OutOrStdout(), tree, members)
|
||||
if people && len(alone) > 0 {
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "\non their own\n")
|
||||
for _, u := range alone {
|
||||
fmt.Fprintf(cmd.OutOrStdout(), " %s %s %s\n", u.Email, u.State, u.ID)
|
||||
}
|
||||
}
|
||||
@@ -71,36 +90,44 @@ func newOrgTreeCmd(open dbOpener) *cobra.Command {
|
||||
return cmd
|
||||
}
|
||||
|
||||
func printTree(w io.Writer, tree []store.TreeOrg, people map[string][]store.User) {
|
||||
func printTree(w io.Writer, tree []store.TreeOrg, members map[string][]string) {
|
||||
if len(tree) == 0 {
|
||||
fmt.Fprintln(w, "no organizations yet; `llmgw org add org <name>` starts one")
|
||||
return
|
||||
}
|
||||
list := func(indent, key string) {
|
||||
for _, m := range members[key] {
|
||||
fmt.Fprintf(w, "%s%s\n", indent, m)
|
||||
}
|
||||
}
|
||||
for _, o := range tree {
|
||||
fmt.Fprintf(w, "%s (%s)\n", o.Name, o.ID)
|
||||
fmt.Fprintf(w, "%s (%s)%s\n", o.Name, o.ID, membersNote(o.Members))
|
||||
list(" · ", "org:"+o.ID)
|
||||
if len(o.Teams) == 0 {
|
||||
fmt.Fprintln(w, " no teams")
|
||||
}
|
||||
for _, t := range o.Teams {
|
||||
fmt.Fprintf(w, " %s (%s)\n", t.Name, t.ID)
|
||||
fmt.Fprintf(w, " %s (%s)%s\n", t.Name, t.ID, membersNote(t.Members))
|
||||
list(" · ", "team:"+t.ID)
|
||||
if len(t.Projects) == 0 {
|
||||
fmt.Fprintln(w, " no projects")
|
||||
}
|
||||
for _, p := range t.Projects {
|
||||
fmt.Fprintf(w, " %s (%s) %s, %s\n", p.Name, p.ID,
|
||||
countOf(p.Users, "account"), keysOf(p))
|
||||
for _, u := range people[p.ID] {
|
||||
admin := ""
|
||||
if u.IsAdmin {
|
||||
admin = " admin"
|
||||
}
|
||||
fmt.Fprintf(w, " %s %s%s\n", u.Email, u.State, admin)
|
||||
}
|
||||
countOf(p.Users, "member"), keysOf(p))
|
||||
list(" · ", "project:"+p.ID)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func membersNote(n int) string {
|
||||
if n == 0 {
|
||||
return ""
|
||||
}
|
||||
return " " + countOf(n, "member")
|
||||
}
|
||||
|
||||
func keysOf(p store.TreeProject) string {
|
||||
s := countOf(p.ActiveKeys, "key")
|
||||
if revoked := p.Keys - p.ActiveKeys; revoked > 0 {
|
||||
|
||||
@@ -51,15 +51,24 @@ func TestTheTreeIsManagedByNameNotId(t *testing.T) {
|
||||
mustRun(t, db, "keys", "create", "laptop", "--project", "gateway")
|
||||
|
||||
out := mustRun(t, db, "org", "tree", "--people")
|
||||
for _, want := range []string{"Acme", "gateway", "1 account, 1 key", "ayse@example.com"} {
|
||||
for _, want := range []string{"Acme", "gateway", "1 member, 1 key", "ayse@example.com"} {
|
||||
if !strings.Contains(out, want) {
|
||||
t.Errorf("tree lacks %q:\n%s", want, out)
|
||||
}
|
||||
}
|
||||
|
||||
out = mustRun(t, db, "users", "move", "ayse@example.com", "--project", "research")
|
||||
out = mustRun(t, db, "users", "join", "ayse@example.com", "--project", "research")
|
||||
if !strings.Contains(out, "Scania / platform / research") {
|
||||
t.Errorf("move said: %s", out)
|
||||
t.Errorf("join said: %s", out)
|
||||
}
|
||||
mustRun(t, db, "users", "leave", "ayse@example.com", "--project", "Acme/platform/gateway")
|
||||
// She now uses the gateway through research alone; a personal key is hers.
|
||||
mustRun(t, db, "keys", "create", "mine", "--for", "ayse@example.com")
|
||||
if out := mustRun(t, db, "keys", "list", "--all"); !strings.Contains(out, "personal") {
|
||||
t.Errorf("a personal key is not listed as one:\n%s", out)
|
||||
}
|
||||
if _, err := run(t, db, "keys", "create", "x", "--for", "ayse@example.com", "--project", "gateway"); err == nil {
|
||||
t.Error("a key was made for her in a project she left")
|
||||
}
|
||||
|
||||
mustRun(t, db, "org", "rename", "project", "research", "lab")
|
||||
|
||||
@@ -59,7 +59,8 @@ func TestInitLeavesAControlPlaneThatStarts(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !u.IsAdmin || u.State != store.UserActive || u.ProjectID != "default" {
|
||||
inDefault, _ := s.CanUseProject(context.Background(), u.ID, "default")
|
||||
if !u.IsAdmin || u.State != store.UserActive || !inDefault {
|
||||
t.Errorf("administrator not ready to use: %+v", u)
|
||||
}
|
||||
if !strings.Contains(out.String(), "password: ") {
|
||||
|
||||
+131
-34
@@ -1,7 +1,9 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"text/tabwriter"
|
||||
"time"
|
||||
|
||||
@@ -33,7 +35,7 @@ func newUsersCmd() *cobra.Command {
|
||||
newUserStateCmd(open, "reinstate", store.UserActive,
|
||||
"Let a suspended account work again"),
|
||||
newUserCreateCmd(open), newUserResetPasswordCmd(open),
|
||||
newUserMoveCmd(open), newUserDeleteCmd(open),
|
||||
newUserJoinCmd(open), newUserLeaveCmd(open), newUserDeleteCmd(open),
|
||||
newUserAdminCmd(open, "promote", true, "Let an account see the cluster dashboard at /admin"),
|
||||
newUserAdminCmd(open, "demote", false, "Take away access to the cluster dashboard"))
|
||||
return cmd
|
||||
@@ -67,16 +69,28 @@ func newUserListCmd(open userOpener) *cobra.Command {
|
||||
return nil
|
||||
}
|
||||
|
||||
all, err := s.AllMemberships(cmd.Context())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
where := map[string][]string{}
|
||||
for _, m := range all {
|
||||
where[m.UserID] = append(where[m.UserID], m.Path)
|
||||
}
|
||||
w := tabwriter.NewWriter(cmd.OutOrStdout(), 0, 0, 2, ' ', 0)
|
||||
fmt.Fprintln(w, "ID\tEMAIL\tNAME\tSTATE\tADMIN\tPROJECT\tSIGNED UP\tLAST LOGIN")
|
||||
fmt.Fprintln(w, "ID\tEMAIL\tSTATE\tADMIN\tMEMBER OF\tSIGNED UP\tLAST LOGIN")
|
||||
now := time.Now()
|
||||
for _, u := range users {
|
||||
admin := "-"
|
||||
if u.IsAdmin {
|
||||
admin = "yes"
|
||||
}
|
||||
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
|
||||
u.ID, u.Email, u.Name, u.State, admin, dash(u.ProjectID),
|
||||
member := "on their own"
|
||||
if ms := where[u.ID]; len(ms) > 0 {
|
||||
member = strings.Join(ms, "; ")
|
||||
}
|
||||
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
|
||||
u.ID, u.Email, u.State, admin, member,
|
||||
ago(u.CreatedAt, now), ago(u.LastLoginAt, now))
|
||||
}
|
||||
return w.Flush()
|
||||
@@ -91,9 +105,9 @@ func newUserApproveCmd(open userOpener) *cobra.Command {
|
||||
cmd := &cobra.Command{
|
||||
Use: "approve <user>",
|
||||
Short: "Let an account sign in and issue its own keys",
|
||||
Long: "The project is required: it decides which limits this person's keys\n" +
|
||||
"inherit. An account approved into no project would pass every check and\n" +
|
||||
"then fail at the first key it tried to make.",
|
||||
Long: "A project is optional. Approved into nothing, a person uses the gateway on\n" +
|
||||
"their own — personal keys and chat within their personal limits — and can\n" +
|
||||
"be added to organizations, teams and projects with 'llmgw users join'.",
|
||||
Args: cobra.ExactArgs(1),
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
s, err := open(cmd)
|
||||
@@ -106,20 +120,26 @@ func newUserApproveCmd(open userOpener) *cobra.Command {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p, err := resolveProject(cmd.Context(), s, project)
|
||||
if err != nil {
|
||||
return err
|
||||
var p store.ProjectPath
|
||||
if project != "" {
|
||||
if p, err = resolveProject(cmd.Context(), s, project); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := s.ApproveUser(cmd.Context(), u.ID, p.ID, by, time.Now()); err != nil {
|
||||
return fmt.Errorf("approving %s: %w", u.Email, err)
|
||||
}
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "%s approved into %s\n", u.Email, p.Path)
|
||||
if p.ID == "" {
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "%s approved, on their own for now\n", u.Email)
|
||||
} else {
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "%s approved into %s\n", u.Email, p.Path)
|
||||
}
|
||||
cmd.PrintErrln("They can sign in and create their own keys from /profile.")
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&project, "project", "",
|
||||
"project the person's keys belong to: id, path (Acme/platform/gateway) or unique name")
|
||||
"a project to put them in (optional): id, path (Acme/platform/gateway) or unique name")
|
||||
cmd.Flags().StringVar(&by, "by", "", "who approved, for the record")
|
||||
return cmd
|
||||
}
|
||||
@@ -254,9 +274,11 @@ func newUserCreateCmd(open userOpener) *cobra.Command {
|
||||
}
|
||||
defer s.Close()
|
||||
|
||||
p, err := resolveProject(cmd.Context(), s, project)
|
||||
if err != nil {
|
||||
return err
|
||||
var p store.ProjectPath
|
||||
if project != "" {
|
||||
if p, err = resolveProject(cmd.Context(), s, project); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
hash, err := account.HashPassword(password)
|
||||
if err != nil {
|
||||
@@ -274,27 +296,64 @@ func newUserCreateCmd(open userOpener) *cobra.Command {
|
||||
return err
|
||||
}
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "%s\n", id)
|
||||
cmd.PrintErrf("%s created and approved into %s\n", args[0], p.Path)
|
||||
if p.ID == "" {
|
||||
cmd.PrintErrf("%s created and approved, on their own for now\n", args[0])
|
||||
} else {
|
||||
cmd.PrintErrf("%s created and approved into %s\n", args[0], p.Path)
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&project, "project", "",
|
||||
"project the person's keys belong to: id, path or unique name (optional when there is one)")
|
||||
"a project to put them in (optional): id, path or unique name")
|
||||
cmd.Flags().StringVar(&password, "password", "", "initial password")
|
||||
return cmd
|
||||
}
|
||||
|
||||
func newUserMoveCmd(open userOpener) *cobra.Command {
|
||||
var project string
|
||||
// scopeFlags names one org, team or project by whichever flag is given.
|
||||
type scopeFlags struct{ org, team, project string }
|
||||
|
||||
func (f *scopeFlags) bind(cmd *cobra.Command) {
|
||||
cmd.Flags().StringVar(&f.org, "org", "", "an organization: id or name")
|
||||
cmd.Flags().StringVar(&f.team, "team", "", "a team: id, path (Acme/ml) or unique name")
|
||||
cmd.Flags().StringVar(&f.project, "project", "", "a project: id, path (Acme/ml/training) or unique name")
|
||||
}
|
||||
|
||||
func (f *scopeFlags) resolve(cmd *cobra.Command, s *store.DB) (store.Scope, string, string, error) {
|
||||
n := 0
|
||||
for _, v := range []string{f.org, f.team, f.project} {
|
||||
if v != "" {
|
||||
n++
|
||||
}
|
||||
}
|
||||
if n != 1 {
|
||||
return "", "", "", fmt.Errorf("give exactly one of --org, --team or --project")
|
||||
}
|
||||
ctx := cmd.Context()
|
||||
switch {
|
||||
case f.org != "":
|
||||
o, err := resolveOrg(ctx, s, f.org)
|
||||
return store.ScopeOrg, o.ID, o.Name, err
|
||||
case f.team != "":
|
||||
t, err := resolveTeam(ctx, s, f.team)
|
||||
return store.ScopeTeam, t.ID, t.OrgName + " / " + t.Name, err
|
||||
default:
|
||||
p, err := resolveProject(ctx, s, f.project)
|
||||
return store.ScopeProject, p.ID, p.Path, err
|
||||
}
|
||||
}
|
||||
|
||||
func newUserJoinCmd(open userOpener) *cobra.Command {
|
||||
var where scopeFlags
|
||||
var role, by string
|
||||
cmd := &cobra.Command{
|
||||
Use: "move <user> --project <project>",
|
||||
Short: "Put an approved account in another project, with the keys it made",
|
||||
Long: "The person's own keys go with them, so they stop spending the old project's\n" +
|
||||
"budget. Keys an operator issued in the old project stay there. Usage already\n" +
|
||||
"recorded is not rewritten. A running server picks the change up when its key\n" +
|
||||
"cache expires (auth.cache_ttl).",
|
||||
Example: " llmgw users move ayse@example.com --project Acme/ml/research",
|
||||
Args: cobra.ExactArgs(1),
|
||||
Use: "join <user> --org|--team|--project <which>",
|
||||
Short: "Make a person a member of an organization, team or project",
|
||||
Long: "A person can be a member of any number of them. A member of a team or\n" +
|
||||
"organization may use every project in it.",
|
||||
Example: " llmgw users join ayse@example.com --team Acme/ml\n" +
|
||||
" llmgw users join ayse@example.com --project Scania/research/vision",
|
||||
Args: cobra.ExactArgs(1),
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
s, err := open(cmd)
|
||||
if err != nil {
|
||||
@@ -305,21 +364,59 @@ func newUserMoveCmd(open userOpener) *cobra.Command {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p, err := resolveProject(cmd.Context(), s, project)
|
||||
scope, id, label, err := where.resolve(cmd, s)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
moved, err := s.MoveUser(cmd.Context(), u.ID, p.ID)
|
||||
if err != nil {
|
||||
if err := s.AddMembership(cmd.Context(), u.ID, scope, id, role, by, time.Now()); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "%s is now in %s (%s moved with them)\n",
|
||||
u.Email, p.Path, countOf(moved, "key"))
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "%s is a %s of %s\n", u.Email, role, label)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&project, "project", "", "where they go: id, path or unique name")
|
||||
_ = cmd.MarkFlagRequired("project")
|
||||
where.bind(cmd)
|
||||
cmd.Flags().StringVar(&role, "role", store.RoleMember, "member (manager is reserved)")
|
||||
cmd.Flags().StringVar(&by, "by", "", "who added them, for the record")
|
||||
return cmd
|
||||
}
|
||||
|
||||
func newUserLeaveCmd(open userOpener) *cobra.Command {
|
||||
var where scopeFlags
|
||||
cmd := &cobra.Command{
|
||||
Use: "leave <user> --org|--team|--project <which>",
|
||||
Short: "Take a person out of an organization, team or project",
|
||||
Long: "Keys they made in a project they can no longer use are revoked; a project\n" +
|
||||
"they still reach through another membership keeps them. Their personal\n" +
|
||||
"keys are not touched.",
|
||||
Args: cobra.ExactArgs(1),
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
s, err := open(cmd)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer s.Close()
|
||||
u, err := resolveUser(cmd.Context(), s, args[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
scope, id, label, err := where.resolve(cmd, s)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
revoked, err := s.RemoveMembership(cmd.Context(), u.ID, scope, id, time.Now())
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
return fmt.Errorf("%s is not a member of %s itself", u.Email, label)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "%s is no longer in %s (%s revoked)\n",
|
||||
u.Email, label, countOf(revoked, "key"))
|
||||
return nil
|
||||
},
|
||||
}
|
||||
where.bind(cmd)
|
||||
return cmd
|
||||
}
|
||||
|
||||
|
||||
@@ -204,6 +204,10 @@ type Auth struct {
|
||||
// means accounts are made with `llmgw users create` instead.
|
||||
SignupOpen bool `koanf:"signup_open"`
|
||||
|
||||
// Personal is what a person may do on their own, outside any project: make
|
||||
// personal keys and use the chat page personally, within these limits.
|
||||
Personal Personal `koanf:"personal"`
|
||||
|
||||
// Pricing is what each model costs, for budgets. A model absent from the
|
||||
// table costs whatever DefaultPrice says, which is nothing unless set.
|
||||
Pricing map[string]Price `koanf:"pricing"`
|
||||
@@ -218,6 +222,22 @@ type Auth struct {
|
||||
BufferSize int `koanf:"buffer_size"`
|
||||
}
|
||||
|
||||
// Personal configures use that belongs to a person rather than a project.
|
||||
//
|
||||
// On by default: a person need not belong to anything to use the gateway. The
|
||||
// limits are each person's own pool across all their personal keys and their
|
||||
// personal chat, and apply only where nobody wrote a limit for that person.
|
||||
type Personal struct {
|
||||
// Disabled refuses personal keys and personal chat; people then use the
|
||||
// gateway only through projects they are members of.
|
||||
Disabled bool `koanf:"disabled"`
|
||||
RPM int `koanf:"rpm"`
|
||||
TPM int `koanf:"tpm"`
|
||||
// Budget is in whole units per Period ("day" or "month").
|
||||
Budget float64 `koanf:"budget"`
|
||||
Period string `koanf:"period"`
|
||||
}
|
||||
|
||||
// Price is a model's cost in micro-units per thousand tokens.
|
||||
//
|
||||
// What a unit means is the operator's choice — self-hosted models have no
|
||||
|
||||
+84
-13
@@ -2,6 +2,7 @@ package router
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
@@ -28,7 +29,15 @@ import (
|
||||
// of the gateway enforces.
|
||||
func (r *Router) registerChat(mux *http.ServeMux, pages *web.AccountPages) {
|
||||
mux.HandleFunc("GET /chat", pages.Guard(func(w http.ResponseWriter, req *http.Request, user store.User) {
|
||||
web.Chat(user, r.modelsFor(req, user), version.Version)(w, req)
|
||||
contexts, _ := r.chatContexts(req.Context(), user)
|
||||
current, err := r.pickContext(req.Context(), user, req.URL.Query().Get("context"))
|
||||
if err != nil {
|
||||
current = ""
|
||||
}
|
||||
if current == "" && !r.personalOff {
|
||||
current = personalContext
|
||||
}
|
||||
web.Chat(user, r.modelsFor(req, user), contexts, current, version.Version)(w, req)
|
||||
}))
|
||||
mux.HandleFunc("POST /chat/send", pages.Guard(r.chatSend))
|
||||
// Behind the same guard as the rest of the page: it takes a POST body and
|
||||
@@ -42,12 +51,6 @@ func (r *Router) registerChat(mux *http.ServeMux, pages *web.AccountPages) {
|
||||
|
||||
// chatSend dispatches one turn on behalf of a signed-in person.
|
||||
func (r *Router) chatSend(w http.ResponseWriter, req *http.Request, user store.User) {
|
||||
principal, err := r.principalFor(req, user)
|
||||
if err != nil {
|
||||
http.Error(w, "your account has no project to bill this to", http.StatusForbidden)
|
||||
return
|
||||
}
|
||||
|
||||
body, err := io.ReadAll(io.LimitReader(req.Body, r.cfg.MaxBodyBytes))
|
||||
if err != nil {
|
||||
http.Error(w, "could not read the request", http.StatusBadRequest)
|
||||
@@ -57,11 +60,19 @@ func (r *Router) chatSend(w http.ResponseWriter, req *http.Request, user store.U
|
||||
var in struct {
|
||||
Model string `json:"model"`
|
||||
Messages []json.RawMessage `json:"messages"`
|
||||
// Context is what this turn spends against: a project id, or
|
||||
// "personal". Checked here, not trusted from the page.
|
||||
Context string `json:"context"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &in); err != nil || in.Model == "" || len(in.Messages) == 0 {
|
||||
http.Error(w, "a model and at least one message are required", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
principal, err := r.principalFor(req, user, in.Context)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusForbidden)
|
||||
return
|
||||
}
|
||||
|
||||
// Rebuilt rather than forwarded, so the page cannot set fields it has no
|
||||
// business setting — a stream:false that would hang the reader, a
|
||||
@@ -115,23 +126,83 @@ func chatTokenCap(m catalog.Model) int {
|
||||
return chatMaxTokens
|
||||
}
|
||||
|
||||
// principalFor builds the identity a signed-in person acts under.
|
||||
// personalContext is how the page names spending as oneself, outside any
|
||||
// project.
|
||||
const personalContext = "personal"
|
||||
|
||||
// chatContexts is what a person may spend against on this page: the projects
|
||||
// they can use, and themselves when personal use is allowed.
|
||||
func (r *Router) chatContexts(ctx context.Context, user store.User) ([]web.ChatContext, error) {
|
||||
var out []web.ChatContext
|
||||
projects, err := r.store.ProjectsFor(ctx, user.ID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, p := range projects {
|
||||
out = append(out, web.ChatContext{Value: p.ID, Label: p.Path})
|
||||
}
|
||||
if !r.personalOff {
|
||||
out = append(out, web.ChatContext{Value: personalContext, Label: "Personal"})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// pickContext resolves what a request asked to spend against, checking the
|
||||
// person may; with nothing asked, their first project, else themselves.
|
||||
// Returns the project id, empty for personal.
|
||||
func (r *Router) pickContext(ctx context.Context, user store.User, asked string) (string, error) {
|
||||
switch {
|
||||
case asked == personalContext:
|
||||
if r.personalOff {
|
||||
return "", errors.New("personal use is off on this gateway")
|
||||
}
|
||||
return "", nil
|
||||
case asked != "":
|
||||
ok, err := r.store.CanUseProject(ctx, user.ID, asked)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !ok {
|
||||
return "", errors.New("you are not a member of that project")
|
||||
}
|
||||
return asked, nil
|
||||
}
|
||||
projects, err := r.store.ProjectsFor(ctx, user.ID)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if len(projects) > 0 {
|
||||
return projects[0].ID, nil
|
||||
}
|
||||
if r.personalOff {
|
||||
return "", errors.New("you are in no project, and personal use is off on this gateway")
|
||||
}
|
||||
return "", nil
|
||||
}
|
||||
|
||||
// principalFor builds the identity a signed-in person acts under, spending
|
||||
// against a project they may use or, with none, themselves.
|
||||
//
|
||||
// The key id is synthetic and marked as a session, because there is no key: it
|
||||
// keeps usage rows attributable and rate limits per person, while making it
|
||||
// obvious in the usage table that these requests came from the page rather than
|
||||
// from a credential somebody holds.
|
||||
func (r *Router) principalFor(req *http.Request, user store.User) (auth.Principal, error) {
|
||||
if r.store == nil || user.ProjectID == "" {
|
||||
return auth.Principal{}, errors.New("no project")
|
||||
func (r *Router) principalFor(req *http.Request, user store.User, asked string) (auth.Principal, error) {
|
||||
if r.store == nil {
|
||||
return auth.Principal{}, errors.New("no store")
|
||||
}
|
||||
eff, err := r.store.ResolveProject(req.Context(), user.ProjectID)
|
||||
project, err := r.pickContext(req.Context(), user, asked)
|
||||
if err != nil {
|
||||
return auth.Principal{}, err
|
||||
}
|
||||
eff, err := r.store.ResolveFor(req.Context(), "session:"+user.ID, user.ID, project)
|
||||
if err != nil {
|
||||
return auth.Principal{}, err
|
||||
}
|
||||
return auth.Principal{
|
||||
KeyID: "session:" + user.ID,
|
||||
KeyPrefix: "session",
|
||||
UserID: user.ID,
|
||||
ProjectID: eff.ProjectID,
|
||||
TeamID: eff.TeamID,
|
||||
OrgID: eff.OrgID,
|
||||
@@ -159,7 +230,7 @@ func (r *Router) principalFor(req *http.Request, user store.User) (auth.Principa
|
||||
// by name, "big-model" came first and every visitor who pressed Send without
|
||||
// touching the picker got placeholder text.
|
||||
func (r *Router) modelsFor(req *http.Request, user store.User) []web.ChatModel {
|
||||
principal, err := r.principalFor(req, user)
|
||||
principal, err := r.principalFor(req, user, req.URL.Query().Get("context"))
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -145,6 +145,8 @@ func (r *Router) Handler() http.Handler {
|
||||
// So the example on the profile page names a model that is actually
|
||||
// running, rather than a placeholder that gets sent as-is.
|
||||
pages.ServedModels(r.exampleModels)
|
||||
pages.SetPersonalOff(r.personalOff)
|
||||
pages.SetPersonalDefaults(r.personalDefaults)
|
||||
pages.Register(mux)
|
||||
r.registerChat(mux, pages)
|
||||
|
||||
@@ -211,6 +213,7 @@ type parsedRequest struct {
|
||||
Band string
|
||||
// KeyID, ProjectID and Tenant are empty when authentication is off.
|
||||
KeyID string
|
||||
UserID string
|
||||
ProjectID string
|
||||
Tenant string
|
||||
ProfileOverride string
|
||||
@@ -416,7 +419,7 @@ func (r *Router) account(req *parsedRequest, res dispatchResult, status int, too
|
||||
return
|
||||
}
|
||||
u := store.Usage{
|
||||
At: time.Now(), KeyID: req.KeyID, ProjectID: req.ProjectID,
|
||||
At: time.Now(), KeyID: req.KeyID, UserID: req.UserID, ProjectID: req.ProjectID,
|
||||
Model: req.Model, ServedModel: res.model, Status: status,
|
||||
LatencyMs: took.Milliseconds(),
|
||||
}
|
||||
@@ -489,6 +492,7 @@ func (r *Router) parse(req *http.Request, path string) (*parsedRequest, error) {
|
||||
p.Band = principal.Band
|
||||
p.ProfileOverride = principal.RoutingProfile
|
||||
p.KeyID = principal.KeyID
|
||||
p.UserID = principal.UserID
|
||||
p.ProjectID = principal.ProjectID
|
||||
// Tenant fairness within a band is per key rather than per session, so
|
||||
// one key cannot take a whole band by opening many sessions.
|
||||
|
||||
@@ -10,6 +10,7 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"math"
|
||||
"net/http"
|
||||
"slices"
|
||||
"strings"
|
||||
@@ -86,6 +87,12 @@ type Router struct {
|
||||
// anonymous means threads has no project to scope to: everything shares the
|
||||
// one pool named by anonymousProject.
|
||||
anonymous bool
|
||||
// personalOff refuses personal use: the chat page then only offers the
|
||||
// projects a person is a member of.
|
||||
personalOff bool
|
||||
// personalDefaults is what personal use is held to when nobody wrote a
|
||||
// limit for the person, for the quota page to say so.
|
||||
personalDefaults *storepkg.Limits
|
||||
// ownsThreads is true when threads is not store and so must be closed here.
|
||||
ownsThreads bool
|
||||
recorder *accounting.Recorder
|
||||
@@ -237,6 +244,9 @@ func New(cfg config.Server, log *slog.Logger) (*Router, error) {
|
||||
defTPM = &cfg.Auth.DefaultTPM
|
||||
}
|
||||
st.SetDefaultLimits(defRPM, defTPM)
|
||||
st.SetPersonalDefaults(personalLimits(cfg.Auth.Personal))
|
||||
r.personalOff = cfg.Auth.Personal.Disabled
|
||||
r.personalDefaults = personalLimits(cfg.Auth.Personal)
|
||||
|
||||
r.auth = auth.New(st, auth.Config{
|
||||
TTL: cfg.Auth.CacheTTL,
|
||||
@@ -699,3 +709,28 @@ func (r *Router) dispatchOne(ctx context.Context, w http.ResponseWriter, req *pa
|
||||
func without(eps []endpoint.Snapshot, id string) []endpoint.Snapshot {
|
||||
return slices.DeleteFunc(slices.Clone(eps), func(e endpoint.Snapshot) bool { return e.ID == id })
|
||||
}
|
||||
|
||||
// personalLimits turns the personal block into limits, nil when it sets none.
|
||||
func personalLimits(p config.Personal) *storepkg.Limits {
|
||||
var l storepkg.Limits
|
||||
if p.RPM > 0 {
|
||||
v := p.RPM
|
||||
l.RPM = &v
|
||||
}
|
||||
if p.TPM > 0 {
|
||||
v := p.TPM
|
||||
l.TPM = &v
|
||||
}
|
||||
if p.Budget > 0 {
|
||||
v := int64(math.Round(p.Budget * 1e6))
|
||||
l.Budget = &v
|
||||
l.BudgetPeriod = storepkg.PeriodMonth
|
||||
if p.Period == "day" {
|
||||
l.BudgetPeriod = storepkg.PeriodDay
|
||||
}
|
||||
}
|
||||
if l.RPM == nil && l.TPM == nil && l.Budget == nil {
|
||||
return nil
|
||||
}
|
||||
return &l
|
||||
}
|
||||
@@ -298,6 +298,14 @@ const anonymousProject = "_anonymous"
|
||||
var errThreadsNeedAuth = errors.New(
|
||||
"a conversation needs an API key: without one there is no project to keep it in")
|
||||
|
||||
// errThreadsPersonal is what a personal key meets. Conversations and notes are
|
||||
// kept per project, with the project's retention; a personal key has none, and
|
||||
// the shared pool an unauthenticated gateway uses is not somewhere a signed-in
|
||||
// person's history belongs.
|
||||
var errThreadsPersonal = errors.New(
|
||||
"conversations and notes are kept per project, and this is a personal key; " +
|
||||
"use a key made in a project that keeps them")
|
||||
|
||||
// errThreadsOff is what a thread header meets when nothing is configured to
|
||||
// keep threads. Refused rather than ignored: ignoring it sends the model a
|
||||
// conversation with no history, and it answers confidently about something it
|
||||
@@ -317,6 +325,8 @@ func (r *Router) threadProject(callerProject string) (string, error) {
|
||||
return "", errThreadsOff
|
||||
case callerProject != "":
|
||||
return callerProject, nil
|
||||
case r.auth != nil:
|
||||
return "", errThreadsPersonal
|
||||
case r.anonymous:
|
||||
return anonymousProject, nil
|
||||
default:
|
||||
|
||||
@@ -23,6 +23,8 @@ var copyOrder = []string{
|
||||
// users is created in a later one than api_keys even though api_keys
|
||||
// points at it — so the copy failed on a foreign key three tables in.
|
||||
"users",
|
||||
// After users and the three levels of the tree, which it points at.
|
||||
"memberships",
|
||||
"api_keys",
|
||||
"key_claims",
|
||||
"sessions",
|
||||
|
||||
@@ -40,7 +40,13 @@ func TestEveryTableIsInTheCopyOrder(t *testing.T) {
|
||||
if len(declared) == 0 {
|
||||
t.Fatal("found no tables in the migrations, so this test proves nothing")
|
||||
}
|
||||
renamed := renamedTables(t)
|
||||
for _, name := range declared {
|
||||
if to, ok := renamed[name]; ok {
|
||||
// A table rebuilt under a temporary name and renamed back is the
|
||||
// table it became, not another one.
|
||||
name = to
|
||||
}
|
||||
if slices.Contains(copyOrder, name) {
|
||||
continue
|
||||
}
|
||||
@@ -204,10 +210,16 @@ func TestTheCopyOrderSatisfiesTheForeignKeys(t *testing.T) {
|
||||
body += string(b)
|
||||
}
|
||||
|
||||
// Table bodies, so a REFERENCES is attributed to the table holding it.
|
||||
// Table bodies, so a REFERENCES is attributed to the table holding it,
|
||||
// under the name it ends with for one rebuilt and renamed.
|
||||
renamed := renamedTables(t)
|
||||
for _, m := range regexpCreateTable.FindAllStringSubmatch(body, -1) {
|
||||
table := m[1]
|
||||
if to, ok := renamed[table]; ok {
|
||||
table = to
|
||||
}
|
||||
for _, r := range regexpReferences.FindAllStringSubmatch(m[2], -1) {
|
||||
note(m[1], r[1])
|
||||
note(table, r[1])
|
||||
}
|
||||
}
|
||||
// And columns added later, which is exactly how api_keys got its user_id.
|
||||
@@ -235,8 +247,29 @@ var (
|
||||
regexpCreateTable = regexp.MustCompile(`(?s)CREATE TABLE (\w+)\s*\((.*?)\n\);`)
|
||||
regexpReferences = regexp.MustCompile(`REFERENCES\s+(\w+)`)
|
||||
regexpAlterRef = regexp.MustCompile(`ALTER TABLE (\w+) ADD COLUMN[^;]*REFERENCES\s+(\w+)`)
|
||||
regexpRename = regexp.MustCompile(`ALTER TABLE (\w+) RENAME TO (\w+)`)
|
||||
)
|
||||
|
||||
// renamedTables maps a table a migration renames to the name it gets.
|
||||
func renamedTables(t *testing.T) map[string]string {
|
||||
t.Helper()
|
||||
out := map[string]string{}
|
||||
entries, err := migrationFS.ReadDir("migrations/sqlite")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, e := range entries {
|
||||
b, err := migrationFS.ReadFile("migrations/sqlite/" + e.Name())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, m := range regexpRename.FindAllStringSubmatch(string(b), -1) {
|
||||
out[m[1]] = m[2]
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func TestAnEmptyBlobDoesNotBecomeNullInTheCopy(t *testing.T) {
|
||||
// key_claims.sealed is emptied the moment a claim is used, so a claimed
|
||||
// row holds an empty blob in a NOT NULL column. An empty blob scans as a
|
||||
|
||||
+43
-51
@@ -17,19 +17,24 @@ var ErrNotEmpty = errors.New("not empty")
|
||||
// whole.
|
||||
type TreeOrg struct {
|
||||
ID, Name string
|
||||
Teams []TreeTeam
|
||||
// Members counts people who are members of the organization itself.
|
||||
Members int
|
||||
Teams []TreeTeam
|
||||
}
|
||||
|
||||
// TreeTeam is a team and its projects.
|
||||
type TreeTeam struct {
|
||||
ID, Name string
|
||||
// Members counts people who are members of the team itself.
|
||||
Members int
|
||||
Projects []TreeProject
|
||||
}
|
||||
|
||||
// TreeProject is a project and what uses it.
|
||||
type TreeProject struct {
|
||||
ID, Name string
|
||||
// Users counts accounts in the project, whatever their state.
|
||||
// Users counts the project's own members, whatever their state; people
|
||||
// who reach it through its team or organization are counted there.
|
||||
Users int
|
||||
// Keys counts every key ever issued in it; ActiveKeys those not revoked.
|
||||
Keys, ActiveKeys int
|
||||
@@ -52,7 +57,7 @@ func (s *DB) Tree(ctx context.Context) ([]TreeOrg, error) {
|
||||
}
|
||||
projects, err := queryAll(ctx, s.db, `
|
||||
SELECT p.id, p.name, p.team_id,
|
||||
(SELECT COUNT(*) FROM users u WHERE u.project_id = p.id),
|
||||
(SELECT COUNT(*) FROM memberships m WHERE m.scope_type = 'project' AND m.scope_id = p.id),
|
||||
(SELECT COUNT(*) FROM api_keys k WHERE k.project_id = p.id),
|
||||
(SELECT COUNT(*) FROM api_keys k WHERE k.project_id = p.id AND k.revoked_at IS NULL)
|
||||
FROM projects p ORDER BY p.name`, nil, func(rows *sql.Rows) (proj, error) {
|
||||
@@ -67,13 +72,34 @@ func (s *DB) Tree(ctx context.Context) ([]TreeOrg, error) {
|
||||
for _, p := range projects {
|
||||
byTeam[p.teamID] = append(byTeam[p.teamID], p.TreeProject)
|
||||
}
|
||||
members := map[string]int{}
|
||||
counts, err := queryAll(ctx, s.db,
|
||||
`SELECT scope_type || ':' || scope_id, COUNT(*) FROM memberships
|
||||
WHERE scope_type IN ('org', 'team') GROUP BY scope_type, scope_id`, nil,
|
||||
func(rows *sql.Rows) (struct {
|
||||
k string
|
||||
n int
|
||||
}, error) {
|
||||
var c struct {
|
||||
k string
|
||||
n int
|
||||
}
|
||||
return c, rows.Scan(&c.k, &c.n)
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, c := range counts {
|
||||
members[c.k] = c.n
|
||||
}
|
||||
byOrg := map[string][]TreeTeam{}
|
||||
for _, t := range teams {
|
||||
byOrg[t.OrgID] = append(byOrg[t.OrgID], TreeTeam{ID: t.ID, Name: t.Name, Projects: byTeam[t.ID]})
|
||||
byOrg[t.OrgID] = append(byOrg[t.OrgID], TreeTeam{ID: t.ID, Name: t.Name,
|
||||
Members: members["team:"+t.ID], Projects: byTeam[t.ID]})
|
||||
}
|
||||
out := make([]TreeOrg, 0, len(orgs))
|
||||
for _, o := range orgs {
|
||||
out = append(out, TreeOrg{ID: o.ID, Name: o.Name, Teams: byOrg[o.ID]})
|
||||
out = append(out, TreeOrg{ID: o.ID, Name: o.Name, Members: members["org:"+o.ID], Teams: byOrg[o.ID]})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
@@ -150,13 +176,15 @@ func (s *DB) MoveProject(ctx context.Context, projectID, teamID string) error {
|
||||
// DeleteOrg removes an organization with no teams, and its limits.
|
||||
func (s *DB) DeleteOrg(ctx context.Context, id string) error {
|
||||
return s.deleteEmpty(ctx, ScopeOrg, id, `DELETE FROM organizations WHERE id = ?`,
|
||||
emptyCheck{`SELECT COUNT(*) FROM teams WHERE org_id = ?`, "team"})
|
||||
emptyCheck{`SELECT COUNT(*) FROM teams WHERE org_id = ?`, "team"},
|
||||
emptyCheck{`SELECT COUNT(*) FROM memberships WHERE scope_type = 'org' AND scope_id = ?`, "member"})
|
||||
}
|
||||
|
||||
// DeleteTeam removes a team with no projects, and its limits.
|
||||
func (s *DB) DeleteTeam(ctx context.Context, id string) error {
|
||||
return s.deleteEmpty(ctx, ScopeTeam, id, `DELETE FROM teams WHERE id = ?`,
|
||||
emptyCheck{`SELECT COUNT(*) FROM projects WHERE team_id = ?`, "project"})
|
||||
emptyCheck{`SELECT COUNT(*) FROM projects WHERE team_id = ?`, "project"},
|
||||
emptyCheck{`SELECT COUNT(*) FROM memberships WHERE scope_type = 'team' AND scope_id = ?`, "member"})
|
||||
}
|
||||
|
||||
// DeleteProject removes a project nobody is in and no key was ever issued in.
|
||||
@@ -166,7 +194,7 @@ func (s *DB) DeleteTeam(ctx context.Context, id string) error {
|
||||
// such a project can be renamed or left, not removed.
|
||||
func (s *DB) DeleteProject(ctx context.Context, id string) error {
|
||||
return s.deleteEmpty(ctx, ScopeProject, id, `DELETE FROM projects WHERE id = ?`,
|
||||
emptyCheck{`SELECT COUNT(*) FROM users WHERE project_id = ?`, "account"},
|
||||
emptyCheck{`SELECT COUNT(*) FROM memberships WHERE scope_type = 'project' AND scope_id = ?`, "member"},
|
||||
emptyCheck{`SELECT COUNT(*) FROM api_keys WHERE project_id = ?`, "key"})
|
||||
}
|
||||
|
||||
@@ -190,7 +218,8 @@ func (s *DB) deleteEmpty(ctx context.Context, scope Scope, id, del string, check
|
||||
return fmt.Errorf("%w: it still has %s", ErrNotEmpty, strings.Join(busy, " and "))
|
||||
}
|
||||
if _, err := c.ExecContext(ctx,
|
||||
`DELETE FROM limits WHERE scope_type = ? AND scope_id = ?`, string(scope), id); err != nil {
|
||||
`DELETE FROM limits WHERE scope_type IN (?, ?) AND scope_id = ?`,
|
||||
string(scope), string(MemberScope(scope)), id); err != nil {
|
||||
return err
|
||||
}
|
||||
res, err := c.ExecContext(ctx, del, id)
|
||||
@@ -204,43 +233,6 @@ func (s *DB) deleteEmpty(ctx context.Context, scope Scope, id, del string, check
|
||||
})
|
||||
}
|
||||
|
||||
// MoveUser puts an approved account in another project, with the keys it
|
||||
// made for itself, and returns how many keys moved.
|
||||
//
|
||||
// The keys move because they are the person's: left behind they would keep
|
||||
// spending the old project's budget under the new project's name. Keys an
|
||||
// operator issued in the project belong to the project and stay. Usage already
|
||||
// recorded stays where it was spent.
|
||||
func (s *DB) MoveUser(ctx context.Context, userID, projectID string) (int, error) {
|
||||
if err := s.exists(ctx, "project", `SELECT COUNT(*) FROM projects WHERE id = ?`, projectID); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
var moved int
|
||||
err := s.inTx(ctx, func(c conn) error {
|
||||
var state string
|
||||
if err := c.QueryRowContext(ctx, `SELECT state FROM users WHERE id = ?`, userID).Scan(&state); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return ErrNotFound
|
||||
}
|
||||
return err
|
||||
}
|
||||
if UserState(state) == UserPending {
|
||||
return errors.New("this account is waiting for approval; approve it into a project instead")
|
||||
}
|
||||
if _, err := c.ExecContext(ctx, `UPDATE users SET project_id = ? WHERE id = ?`, projectID, userID); err != nil {
|
||||
return err
|
||||
}
|
||||
res, err := c.ExecContext(ctx, `UPDATE api_keys SET project_id = ? WHERE user_id = ?`, projectID, userID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
n, _ := res.RowsAffected()
|
||||
moved = int(n)
|
||||
return nil
|
||||
})
|
||||
return moved, err
|
||||
}
|
||||
|
||||
// DeleteUser removes an account: its sessions end, its keys are revoked, and
|
||||
// the row goes.
|
||||
//
|
||||
@@ -278,17 +270,17 @@ type KeyRow struct {
|
||||
|
||||
// AllKeys lists every key, newest first, with its project's path and owner.
|
||||
func (s *DB) AllKeys(ctx context.Context) ([]KeyRow, error) {
|
||||
cols := make([]string, 0, 11)
|
||||
cols := make([]string, 0, 12)
|
||||
for _, c := range strings.Split(keyColumns, ",") {
|
||||
cols = append(cols, "k."+strings.TrimSpace(c))
|
||||
}
|
||||
return queryAll(ctx, s.db, `
|
||||
SELECT `+strings.Join(cols, ", ")+`,
|
||||
o.name || ' / ' || t.name || ' / ' || p.name, COALESCE(u.email, '')
|
||||
COALESCE(o.name || ' / ' || t.name || ' / ' || p.name, ''), COALESCE(u.email, '')
|
||||
FROM api_keys k
|
||||
JOIN projects p ON p.id = k.project_id
|
||||
JOIN teams t ON t.id = p.team_id
|
||||
JOIN organizations o ON o.id = t.org_id
|
||||
LEFT JOIN projects p ON p.id = k.project_id
|
||||
LEFT JOIN teams t ON t.id = p.team_id
|
||||
LEFT JOIN organizations o ON o.id = t.org_id
|
||||
LEFT JOIN users u ON u.id = k.user_id
|
||||
ORDER BY k.created_at DESC`, nil, func(rows *sql.Rows) (KeyRow, error) {
|
||||
var r KeyRow
|
||||
|
||||
@@ -19,9 +19,16 @@ type fixture struct {
|
||||
}
|
||||
|
||||
func newFixture(t *testing.T) fixture {
|
||||
t.Helper()
|
||||
return newFixtureOn(t, tenancyStore(t))
|
||||
}
|
||||
|
||||
// newFixtureOn builds the fixture in a given store, so the same cases run on
|
||||
// PostgreSQL as on SQLite.
|
||||
func newFixtureOn(t *testing.T, db *DB) fixture {
|
||||
t.Helper()
|
||||
ctx := t.Context()
|
||||
f := fixture{s: tenancyStore(t)}
|
||||
f := fixture{s: db}
|
||||
must := func(id string, err error) string {
|
||||
t.Helper()
|
||||
if err != nil {
|
||||
@@ -73,48 +80,25 @@ func TestTreeCountsWhatUsesEachProject(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestMovingAUserTakesTheirKeysAndLeavesTheProjects(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
moved, err := f.s.MoveUser(ctx, f.user, f.research)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if moved != 1 {
|
||||
t.Errorf("moved %d keys, want the one the person made", moved)
|
||||
}
|
||||
u, _ := f.s.UserByID(ctx, f.user)
|
||||
if u.ProjectID != f.research {
|
||||
t.Errorf("user is in %s", u.ProjectID)
|
||||
}
|
||||
keys, _ := f.s.Keys(ctx, f.gateway)
|
||||
if len(keys) != 1 || keys[0].ID != f.operatorKey {
|
||||
t.Errorf("the operator's key should stay in the project: %+v", keys)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPendingAccountIsApprovedNotMoved(t *testing.T) {
|
||||
func TestASignupNeverApprovedCannotBeReinstated(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
_ = f.s.CreateUser(ctx, User{ID: "usr-2", Email: "b@x", Name: "b", PasswordHash: "h",
|
||||
State: UserPending, CreatedAt: time.Now()})
|
||||
if _, err := f.s.MoveUser(ctx, "usr-2", f.gateway); err == nil {
|
||||
t.Error("moving a pending account should be refused")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnAccountWithNoProjectCannotBeMadeActive(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
_ = f.s.CreateUser(ctx, User{ID: "usr-2", Email: "b@x", Name: "b", PasswordHash: "h",
|
||||
State: UserPending, CreatedAt: time.Now()})
|
||||
// Rejected, then reinstated: the path that used to produce an active
|
||||
// account whose first key failed.
|
||||
// Suspended while pending, then reinstated: that would be an approval
|
||||
// nobody made.
|
||||
if err := f.s.SetUserState(ctx, "usr-2", UserSuspended); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := f.s.SetUserState(ctx, "usr-2", UserActive); err == nil {
|
||||
t.Error("an account with no project was made active")
|
||||
t.Error("an account nobody approved was made active")
|
||||
}
|
||||
// One that was approved can be.
|
||||
if err := f.s.SetUserState(ctx, f.user, UserSuspended); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := f.s.SetUserState(ctx, f.user, UserActive); err != nil {
|
||||
t.Errorf("an approved account could not be reinstated: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -173,7 +157,7 @@ func TestOnlyEmptyThingsAreDeleted(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
err := f.s.DeleteProject(ctx, f.gateway)
|
||||
if !errors.Is(err, ErrNotEmpty) || !strings.Contains(err.Error(), "1 account and 2 keys") {
|
||||
if !errors.Is(err, ErrNotEmpty) || !strings.Contains(err.Error(), "1 member and 2 keys") {
|
||||
t.Errorf("deleting a used project: %v", err)
|
||||
}
|
||||
if err := f.s.DeleteTeam(ctx, f.platform); !errors.Is(err, ErrNotEmpty) {
|
||||
|
||||
@@ -0,0 +1,284 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ErrNotMember means a person asked to use a project they are not in.
|
||||
var ErrNotMember = errors.New("not a member of that project")
|
||||
|
||||
// Roles a membership can carry.
|
||||
const (
|
||||
RoleMember = "member"
|
||||
// RoleManager is reserved for delegated administration of a scope.
|
||||
RoleManager = "manager"
|
||||
)
|
||||
|
||||
// Membership is a person's place at one level of the tree.
|
||||
type Membership struct {
|
||||
UserID string
|
||||
Scope Scope // org, team or project
|
||||
ScopeID string
|
||||
Role string
|
||||
// Path is where it is: "Acme", "Acme / ml", "Acme / ml / training".
|
||||
Path string
|
||||
AddedAt time.Time
|
||||
AddedBy string
|
||||
}
|
||||
|
||||
func validMembershipScope(s Scope) bool {
|
||||
return s == ScopeOrg || s == ScopeTeam || s == ScopeProject
|
||||
}
|
||||
|
||||
// AddMembership puts a person in an organization, team or project. Adding one
|
||||
// that exists changes nothing but its role.
|
||||
func (s *DB) AddMembership(ctx context.Context, userID string, scope Scope, scopeID, role, by string, at time.Time) error {
|
||||
if !validMembershipScope(scope) {
|
||||
return fmt.Errorf("a membership is in an org, team or project, not %q", scope)
|
||||
}
|
||||
if role == "" {
|
||||
role = RoleMember
|
||||
}
|
||||
table := map[Scope]string{ScopeOrg: "organizations", ScopeTeam: "teams", ScopeProject: "projects"}[scope]
|
||||
if err := s.exists(ctx, string(scope), `SELECT COUNT(*) FROM `+table+` WHERE id = ?`, scopeID); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := s.db.ExecContext(ctx, `
|
||||
INSERT INTO memberships (user_id, scope_type, scope_id, role, added_at, added_by)
|
||||
VALUES (?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT (user_id, scope_type, scope_id) DO UPDATE SET role = excluded.role`,
|
||||
userID, string(scope), scopeID, role, millis(at), nullString(by))
|
||||
return err
|
||||
}
|
||||
|
||||
// RemoveMembership takes a person out of a scope and revokes the keys they
|
||||
// made in any project they can no longer use, returning how many.
|
||||
//
|
||||
// Revoked rather than turned personal: a key made in a project spends that
|
||||
// project's budget, and quietly moving it to the person would carry access
|
||||
// out of the project the operator just removed them from.
|
||||
func (s *DB) RemoveMembership(ctx context.Context, userID string, scope Scope, scopeID string, at time.Time) (int, error) {
|
||||
var revoked int
|
||||
err := s.inTx(ctx, func(c conn) error {
|
||||
res, err := c.ExecContext(ctx,
|
||||
`DELETE FROM memberships WHERE user_id = ? AND scope_type = ? AND scope_id = ?`,
|
||||
userID, string(scope), scopeID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if n, _ := res.RowsAffected(); n == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
res, err = c.ExecContext(ctx, `
|
||||
UPDATE api_keys SET revoked_at = ?
|
||||
WHERE user_id = ? AND project_id IS NOT NULL AND revoked_at IS NULL
|
||||
AND project_id NOT IN (`+usableProjects+`)`,
|
||||
millis(at), userID, userID, userID, userID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
n, _ := res.RowsAffected()
|
||||
revoked = int(n)
|
||||
return nil
|
||||
})
|
||||
return revoked, err
|
||||
}
|
||||
|
||||
// usableProjects selects every project a person may use: those they are a
|
||||
// member of, and every project under a team or organization they are a member
|
||||
// of. Takes the user id three times.
|
||||
const usableProjects = `
|
||||
SELECT m.scope_id FROM memberships m
|
||||
WHERE m.user_id = ? AND m.scope_type = 'project'
|
||||
UNION
|
||||
SELECT p.id FROM projects p JOIN memberships m ON m.scope_type = 'team' AND m.scope_id = p.team_id
|
||||
WHERE m.user_id = ?
|
||||
UNION
|
||||
SELECT p.id FROM projects p JOIN teams t ON t.id = p.team_id
|
||||
JOIN memberships m ON m.scope_type = 'org' AND m.scope_id = t.org_id
|
||||
WHERE m.user_id = ?`
|
||||
|
||||
// CanUseProject reports whether a person may make and use keys in a project.
|
||||
func (s *DB) CanUseProject(ctx context.Context, userID, projectID string) (bool, error) {
|
||||
var n int
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM (`+usableProjects+`) u WHERE u.scope_id = ?`,
|
||||
userID, userID, userID, projectID).Scan(&n)
|
||||
return n > 0, err
|
||||
}
|
||||
|
||||
// ProjectsFor lists the projects a person may use, with their paths.
|
||||
func (s *DB) ProjectsFor(ctx context.Context, userID string) ([]ProjectPath, error) {
|
||||
return queryAll(ctx, s.db, `
|
||||
SELECT p.id, o.name || ' / ' || t.name || ' / ' || p.name
|
||||
FROM projects p
|
||||
JOIN teams t ON t.id = p.team_id
|
||||
JOIN organizations o ON o.id = t.org_id
|
||||
WHERE p.id IN (`+usableProjects+`)
|
||||
ORDER BY 2`, []any{userID, userID, userID}, func(rows *sql.Rows) (ProjectPath, error) {
|
||||
var p ProjectPath
|
||||
return p, rows.Scan(&p.ID, &p.Path)
|
||||
})
|
||||
}
|
||||
|
||||
// membershipPath names the scope of a membership row as a path.
|
||||
const membershipPath = `
|
||||
CASE m.scope_type
|
||||
WHEN 'org' THEN (SELECT o.name FROM organizations o WHERE o.id = m.scope_id)
|
||||
WHEN 'team' THEN (SELECT o.name || ' / ' || t.name FROM teams t
|
||||
JOIN organizations o ON o.id = t.org_id WHERE t.id = m.scope_id)
|
||||
ELSE (SELECT o.name || ' / ' || t.name || ' / ' || p.name FROM projects p
|
||||
JOIN teams t ON t.id = p.team_id JOIN organizations o ON o.id = t.org_id
|
||||
WHERE p.id = m.scope_id)
|
||||
END`
|
||||
|
||||
func scanMembership(rows *sql.Rows) (Membership, error) {
|
||||
var m Membership
|
||||
var scope string
|
||||
var path, by sql.NullString
|
||||
var added int64
|
||||
err := rows.Scan(&m.UserID, &scope, &m.ScopeID, &m.Role, &added, &by, &path)
|
||||
m.Scope, m.Path, m.AddedBy, m.AddedAt = Scope(scope), path.String, by.String, fromMillis(added)
|
||||
return m, err
|
||||
}
|
||||
|
||||
// MembershipsOf lists where a person is a member, by path.
|
||||
func (s *DB) MembershipsOf(ctx context.Context, userID string) ([]Membership, error) {
|
||||
return queryAll(ctx, s.db, `
|
||||
SELECT m.user_id, m.scope_type, m.scope_id, m.role, m.added_at, m.added_by, `+membershipPath+`
|
||||
FROM memberships m WHERE m.user_id = ? ORDER BY 7`, []any{userID}, scanMembership)
|
||||
}
|
||||
|
||||
// AllMemberships lists every membership, for a page that shows the tree with
|
||||
// its people.
|
||||
func (s *DB) AllMemberships(ctx context.Context) ([]Membership, error) {
|
||||
return queryAll(ctx, s.db, `
|
||||
SELECT m.user_id, m.scope_type, m.scope_id, m.role, m.added_at, m.added_by, `+membershipPath+`
|
||||
FROM memberships m ORDER BY 7`, nil, scanMembership)
|
||||
}
|
||||
|
||||
// SetPersonalDefaults sets the limits a person's own use falls under when
|
||||
// nobody wrote a limit for that person: what a personal key, with no project
|
||||
// to be bounded by, gets. Nil clears them.
|
||||
func (s *DB) SetPersonalDefaults(l *Limits) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if l == nil {
|
||||
s.personal = nil
|
||||
return
|
||||
}
|
||||
c := *l
|
||||
s.personal = &c
|
||||
}
|
||||
|
||||
// Resolve walks a key's chain and returns the most restrictive of each limit.
|
||||
func (s *DB) Resolve(ctx context.Context, keyID string) (Effective, error) {
|
||||
var e Effective
|
||||
var band, profile, project, user sql.NullString
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT id, band, routing_profile, project_id, user_id FROM api_keys WHERE id = ?`, keyID).
|
||||
Scan(&e.KeyID, &band, &profile, &project, &user)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return Effective{}, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return Effective{}, err
|
||||
}
|
||||
e.Band, e.RoutingProfile = band.String, profile.String
|
||||
e.ProjectID, e.UserID = project.String, user.String
|
||||
return e, s.resolveChain(ctx, &e, true)
|
||||
}
|
||||
|
||||
// ResolveFor resolves a caller that has no key row: the chat page, spending
|
||||
// as a person in a project or, with no project, personally.
|
||||
func (s *DB) ResolveFor(ctx context.Context, callerID, userID, projectID string) (Effective, error) {
|
||||
e := Effective{KeyID: callerID, UserID: userID, ProjectID: projectID}
|
||||
return e, s.resolveChain(ctx, &e, false)
|
||||
}
|
||||
|
||||
// resolveChain fills in the tree above a caller and folds every limit that
|
||||
// applies: the project's chain, each per-member limit on it for this person,
|
||||
// the person's own, and the key's.
|
||||
//
|
||||
// One pool per level. A budget on a team is spent by everything beneath it; a
|
||||
// person's limit by every key they own; a per-member limit by one person
|
||||
// within one scope.
|
||||
func (s *DB) resolveChain(ctx context.Context, e *Effective, keyLevel bool) error {
|
||||
if e.ProjectID != "" {
|
||||
err := s.db.QueryRowContext(ctx,
|
||||
`SELECT t.id, t.org_id FROM projects p JOIN teams t ON t.id = p.team_id WHERE p.id = ?`,
|
||||
e.ProjectID).Scan(&e.TeamID, &e.OrgID)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
type step struct {
|
||||
scope Scope
|
||||
id string
|
||||
// counter is where use is counted, when it is not the scope's own id.
|
||||
counter string
|
||||
}
|
||||
var steps []step
|
||||
if e.ProjectID != "" {
|
||||
steps = append(steps, step{ScopeOrg, e.OrgID, ""}, step{ScopeTeam, e.TeamID, ""},
|
||||
step{ScopeProject, e.ProjectID, ""})
|
||||
if e.UserID != "" {
|
||||
for _, lvl := range []step{{ScopeOrg, e.OrgID, ""}, {ScopeTeam, e.TeamID, ""}, {ScopeProject, e.ProjectID, ""}} {
|
||||
ms := MemberScope(lvl.scope)
|
||||
steps = append(steps, step{ms, lvl.id, MemberOwner(ms, lvl.id, e.UserID).ID})
|
||||
}
|
||||
}
|
||||
}
|
||||
if e.UserID != "" {
|
||||
steps = append(steps, step{ScopeUser, e.UserID, ""})
|
||||
}
|
||||
if keyLevel {
|
||||
steps = append(steps, step{ScopeKey, e.KeyID, ""})
|
||||
}
|
||||
|
||||
sawUser := false
|
||||
for _, st := range steps {
|
||||
l, err := s.LimitsFor(ctx, st.scope, st.id)
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if st.counter != "" {
|
||||
l.ScopeID = st.counter
|
||||
}
|
||||
if st.scope == ScopeUser {
|
||||
sawUser = true
|
||||
}
|
||||
e.tighten(l)
|
||||
// Kept whole as well as folded in. Enforcement walks this; the folded
|
||||
// values are for showing somebody their ceiling.
|
||||
e.Chain = append(e.Chain, l)
|
||||
}
|
||||
|
||||
// A personal caller has no project to be bounded by. With no limit written
|
||||
// for the person, the personal defaults stand in for one — counted in the
|
||||
// person's own pool, so every personal key they hold shares it.
|
||||
if e.ProjectID == "" && e.UserID != "" && !sawUser {
|
||||
s.mu.RLock()
|
||||
p := s.personal
|
||||
s.mu.RUnlock()
|
||||
if p != nil {
|
||||
l := *p
|
||||
l.Scope, l.ScopeID = ScopeUser, e.UserID
|
||||
e.tighten(l)
|
||||
e.Chain = append(e.Chain, l)
|
||||
}
|
||||
}
|
||||
s.applyDefaults(e)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestApprovalNeedNotPutAnybodyAnywhere(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
_ = f.s.CreateUser(ctx, User{ID: "usr-2", Email: "b@x", Name: "b", PasswordHash: "h",
|
||||
State: UserPending, CreatedAt: time.Now()})
|
||||
if err := f.s.ApproveUser(ctx, "usr-2", "", "test", time.Now()); err != nil {
|
||||
t.Fatalf("approving with no project: %v", err)
|
||||
}
|
||||
ms, _ := f.s.MembershipsOf(ctx, "usr-2")
|
||||
if len(ms) != 0 {
|
||||
t.Errorf("memberships = %+v", ms)
|
||||
}
|
||||
}
|
||||
|
||||
func TestATeamMemberUsesEveryProjectInTheTeam(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
if err := f.s.AddMembership(ctx, f.user, ScopeTeam, f.ml, RoleMember, "test", time.Now()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for proj, want := range map[string]bool{f.gateway: true, f.research: true, f.search: false} {
|
||||
ok, err := f.s.CanUseProject(ctx, f.user, proj)
|
||||
if err != nil || ok != want {
|
||||
t.Errorf("%s: %v %v, want %v", proj, ok, err, want)
|
||||
}
|
||||
}
|
||||
projects, _ := f.s.ProjectsFor(ctx, f.user)
|
||||
if len(projects) != 2 {
|
||||
t.Errorf("projects = %+v", projects)
|
||||
}
|
||||
ms, _ := f.s.MembershipsOf(ctx, f.user)
|
||||
var paths []string
|
||||
for _, m := range ms {
|
||||
paths = append(paths, m.Path)
|
||||
}
|
||||
if len(paths) != 2 || paths[0] != "Acme / platform / gateway" || paths[1] != "Scania / ml" {
|
||||
t.Errorf("paths = %v", paths)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAKeyCanOnlyBeMadeWhereThePersonIsAMember(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
_, k, _ := NewKey("key-x", "x", f.search)
|
||||
if err := f.s.CreateUserKey(ctx, f.user, k); !errors.Is(err, ErrNotMember) {
|
||||
t.Errorf("a key in a project the person is not in: %v", err)
|
||||
}
|
||||
_, k, _ = NewKey("key-p", "personal", "")
|
||||
if err := f.s.CreateUserKey(ctx, f.user, k); err != nil {
|
||||
t.Fatalf("a personal key: %v", err)
|
||||
}
|
||||
got, err := f.s.KeyByHash(ctx, k.Hash)
|
||||
if err != nil || got.ProjectID != "" || got.UserID != f.user {
|
||||
t.Errorf("personal key read back as %+v, %v", got, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLeavingAProjectRevokesTheKeysMadeThereOnly(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
_, personal, _ := NewKey("key-p", "personal", "")
|
||||
if err := f.s.CreateUserKey(ctx, f.user, personal); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
revoked, err := f.s.RemoveMembership(ctx, f.user, ScopeProject, f.gateway, time.Now())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if revoked != 1 {
|
||||
t.Errorf("revoked %d keys, want the one made in gateway", revoked)
|
||||
}
|
||||
keys, _ := f.s.KeysForUser(ctx, f.user)
|
||||
for _, k := range keys {
|
||||
if k.ID == personal.ID && !k.RevokedAt.IsZero() {
|
||||
t.Error("leaving a project revoked a personal key")
|
||||
}
|
||||
}
|
||||
gw, _ := f.s.Keys(ctx, f.gateway)
|
||||
for _, k := range gw {
|
||||
if k.ID == f.operatorKey && !k.RevokedAt.IsZero() {
|
||||
t.Error("an operator's key went with the person")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLeavingKeepsKeysReachedAnotherWay(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
// Also a member of the whole organization, so gateway stays usable.
|
||||
if err := f.s.AddMembership(ctx, f.user, ScopeOrg, f.acme, RoleMember, "", time.Now()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
revoked, err := f.s.RemoveMembership(ctx, f.user, ScopeProject, f.gateway, time.Now())
|
||||
if err != nil || revoked != 0 {
|
||||
t.Errorf("revoked %d, %v; the organization still reaches gateway", revoked, err)
|
||||
}
|
||||
}
|
||||
|
||||
func i(v int) *int { return &v }
|
||||
|
||||
func TestAPersonalKeyIsBoundedByThePerson(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
_, k, _ := NewKey("key-p", "personal", "")
|
||||
if err := f.s.CreateUserKey(ctx, f.user, k); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Nothing written for the person: the personal defaults apply, in the
|
||||
// person's own pool.
|
||||
f.s.SetPersonalDefaults(&Limits{RPM: i(10), TPM: i(5000)})
|
||||
e, err := f.s.Resolve(ctx, k.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("resolving a personal key: %v", err)
|
||||
}
|
||||
if e.ProjectID != "" || e.UserID != f.user || e.RPM == nil || *e.RPM != 10 ||
|
||||
e.RPMOwner != (LimitOwner{ScopeUser, f.user}) {
|
||||
t.Errorf("personal key resolved to %+v", e)
|
||||
}
|
||||
|
||||
// Written for the person: that wins over the defaults.
|
||||
if err := f.s.PutLimits(ctx, Limits{Scope: ScopeUser, ScopeID: f.user, RPM: i(3)}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
e, _ = f.s.Resolve(ctx, k.ID)
|
||||
if *e.RPM != 3 || e.TPM != nil {
|
||||
t.Errorf("the person's own limit should replace the defaults: %+v", e)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAProjectKeyAnswersToThePersonAndEachMemberLimit(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
_, k, _ := NewKey("key-g", "gw", f.gateway)
|
||||
if err := f.s.CreateUserKey(ctx, f.user, k); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
must := func(l Limits) {
|
||||
t.Helper()
|
||||
if err := f.s.PutLimits(ctx, l); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
must(Limits{Scope: ScopeProject, ScopeID: f.gateway, RPM: i(100)})
|
||||
must(Limits{Scope: ScopeProjectMember, ScopeID: f.gateway, RPM: i(20)})
|
||||
must(Limits{Scope: ScopeUser, ScopeID: f.user, TPM: i(700)})
|
||||
|
||||
e, err := f.s.Resolve(ctx, k.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if *e.RPM != 20 || e.RPMOwner != MemberOwner(ScopeProjectMember, f.gateway, f.user) {
|
||||
t.Errorf("the per-member limit should hold this person to 20: %+v", e)
|
||||
}
|
||||
if *e.TPM != 700 || e.TPMOwner != (LimitOwner{ScopeUser, f.user}) {
|
||||
t.Errorf("the person's own limit should apply in a project too: %+v", e)
|
||||
}
|
||||
// Every pool is kept for enforcement, not just the tightest.
|
||||
var scopes []Scope
|
||||
for _, l := range e.Chain {
|
||||
scopes = append(scopes, l.Scope)
|
||||
}
|
||||
if len(scopes) < 3 {
|
||||
t.Errorf("chain = %v", scopes)
|
||||
}
|
||||
|
||||
// An operator's key in the same project has no member and no person.
|
||||
e, _ = f.s.Resolve(ctx, f.operatorKey)
|
||||
if *e.RPM != 100 {
|
||||
t.Errorf("an ownerless key is bounded by the project alone: %+v", e)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSpendIsRestoredForPeopleAndPersonalKeys(t *testing.T) {
|
||||
f := newFixture(t)
|
||||
ctx := t.Context()
|
||||
now := time.Now()
|
||||
if err := f.s.WriteUsage(ctx, []Usage{
|
||||
{At: now, KeyID: "key-p", UserID: f.user, CostMicros: 5, Model: "m", ServedModel: "m"},
|
||||
{At: now, KeyID: "key-u", UserID: f.user, ProjectID: f.gateway, CostMicros: 7, Model: "m", ServedModel: "m"},
|
||||
{At: now, KeyID: "session:" + f.user, UserID: f.user, CostMicros: 11, Model: "m", ServedModel: "m"},
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rows, err := f.s.SpendSinceByScope(ctx, now.Add(-time.Hour))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var personal, project, total int64
|
||||
for _, r := range rows {
|
||||
if r.UserID != f.user {
|
||||
t.Errorf("row not attributed to the person: %+v", r)
|
||||
}
|
||||
total += r.Micros
|
||||
if r.ProjectID == "" {
|
||||
personal += r.Micros
|
||||
} else if r.OrgID == f.acme {
|
||||
project += r.Micros
|
||||
}
|
||||
}
|
||||
if total != 23 || personal != 16 || project != 7 {
|
||||
t.Errorf("total %d personal %d project %d", total, personal, project)
|
||||
}
|
||||
}
|
||||
@@ -95,8 +95,36 @@ func migrationNames(dialect string) ([]string, error) {
|
||||
return names, nil
|
||||
}
|
||||
|
||||
// fkOffMarker in a SQLite migration runs it with foreign keys off.
|
||||
//
|
||||
// Rebuilding a table — the only way SQLite changes a column's constraints —
|
||||
// drops the old one, and with foreign keys on that deletes every row other
|
||||
// tables point at. SQLite's procedure for this turns them off, which only
|
||||
// works outside a transaction, so this takes one connection, turns them off
|
||||
// on it, runs the migration in a transaction there, and refuses to commit
|
||||
// unless foreign_key_check finds nothing.
|
||||
const fkOffMarker = "-- migrate: foreign_keys=off"
|
||||
|
||||
func applyOne(ctx context.Context, db *sql.DB, dialect, name, body string) error {
|
||||
tx, err := db.BeginTx(ctx, nil)
|
||||
type execer interface {
|
||||
BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
|
||||
}
|
||||
var on execer = db
|
||||
checkFKs := false
|
||||
if dialect == string(SQLiteDialect) && strings.Contains(body, fkOffMarker) {
|
||||
c, err := db.Conn(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer c.Close()
|
||||
if _, err := c.ExecContext(ctx, `PRAGMA foreign_keys = OFF`); err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _, _ = c.ExecContext(context.WithoutCancel(ctx), `PRAGMA foreign_keys = ON`) }()
|
||||
on, checkFKs = c, true
|
||||
}
|
||||
|
||||
tx, err := on.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -105,6 +133,17 @@ func applyOne(ctx context.Context, db *sql.DB, dialect, name, body string) error
|
||||
if _, err := tx.ExecContext(ctx, body); err != nil {
|
||||
return err
|
||||
}
|
||||
if checkFKs {
|
||||
rows, err := tx.QueryContext(ctx, `PRAGMA foreign_key_check`)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
broken := rows.Next()
|
||||
rows.Close()
|
||||
if broken {
|
||||
return fmt.Errorf("leaves foreign keys pointing at nothing; not applied")
|
||||
}
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
Dialect(dialect).rebind(`INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)`),
|
||||
name, nowMillis(),
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Migration 0010 rebuilds api_keys on SQLite, a kind of migration this store
|
||||
// had never run. Checked against a store that already has what a running
|
||||
// cluster has: a person in a project, their key, a pending claim pointing at
|
||||
// the key, and usage — including the chat page's, which has no key row.
|
||||
func TestMigration0010KeepsAnExistingStoreWhole(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
path := filepath.Join(t.TempDir(), "old.db")
|
||||
db, err := sql.Open("sqlite", path+"?_pragma=foreign_keys(1)")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer db.Close()
|
||||
db.SetMaxOpenConns(1)
|
||||
|
||||
if _, err := db.ExecContext(ctx,
|
||||
`CREATE TABLE schema_migrations (version TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
names, err := migrationNames("sqlite")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, name := range names {
|
||||
if name >= "0010" {
|
||||
break
|
||||
}
|
||||
body, _ := migrationFS.ReadFile("migrations/sqlite/" + name)
|
||||
if err := applyOne(ctx, db, "sqlite", name, string(body)); err != nil {
|
||||
t.Fatalf("%s: %v", name, err)
|
||||
}
|
||||
}
|
||||
|
||||
for _, q := range []string{
|
||||
`INSERT INTO organizations (id, name) VALUES ('o', 'Acme')`,
|
||||
`INSERT INTO teams (id, org_id, name) VALUES ('t', 'o', 'ml')`,
|
||||
`INSERT INTO projects (id, team_id, name) VALUES ('p', 't', 'training')`,
|
||||
`INSERT INTO users (id, email, name, password_hash, state, project_id, created_at, approved_at, approved_by)
|
||||
VALUES ('u', 'a@x', 'a', 'h', 'active', 'p', 1, 2, 'admin@x')`,
|
||||
`INSERT INTO users (id, email, name, password_hash, state, created_at)
|
||||
VALUES ('w', 'w@x', 'w', 'h', 'pending', 1)`,
|
||||
`INSERT INTO api_keys (id, key_hash, key_prefix, name, project_id, created_at, user_id)
|
||||
VALUES ('k', X'01', 'sk-1', 'laptop', 'p', 1, 'u')`,
|
||||
`INSERT INTO api_keys (id, key_hash, key_prefix, name, project_id, created_at)
|
||||
VALUES ('ops', X'02', 'sk-2', 'ci', 'p', 1)`,
|
||||
`INSERT INTO key_claims (token_hash, key_id, sealed, created_at, expires_at) VALUES (X'aa', 'k', X'00', 1, 9)`,
|
||||
`INSERT INTO usage (ts, key_id, project_id, model, served_model, prompt_tokens, completion_tokens,
|
||||
cost_micros, status, latency_ms) VALUES (5, 'k', 'p', 'm', 'm', 1, 1, 3, 200, 1)`,
|
||||
`INSERT INTO usage (ts, key_id, project_id, model, served_model, prompt_tokens, completion_tokens,
|
||||
cost_micros, status, latency_ms) VALUES (6, 'session:u', 'p', 'm', 'm', 1, 1, 4, 200, 1)`,
|
||||
`INSERT INTO usage (ts, key_id, project_id, model, served_model, prompt_tokens, completion_tokens,
|
||||
cost_micros, status, latency_ms) VALUES (7, 'ops', 'p', 'm', 'm', 1, 1, 5, 200, 1)`,
|
||||
} {
|
||||
if _, err := db.ExecContext(ctx, q); err != nil {
|
||||
t.Fatalf("%s: %v", q, err)
|
||||
}
|
||||
}
|
||||
|
||||
if err := migrate(ctx, db, "sqlite"); err != nil {
|
||||
t.Fatalf("migrating: %v", err)
|
||||
}
|
||||
|
||||
one := func(q string, args ...any) string {
|
||||
t.Helper()
|
||||
var v sql.NullString
|
||||
if err := db.QueryRowContext(ctx, q, args...).Scan(&v); err != nil {
|
||||
t.Fatalf("%s: %v", q, err)
|
||||
}
|
||||
return v.String
|
||||
}
|
||||
if got := one(`SELECT COUNT(*) FROM api_keys`); got != "2" {
|
||||
t.Errorf("keys after the rebuild: %s", got)
|
||||
}
|
||||
if got := one(`SELECT user_id FROM api_keys WHERE id = 'k'`); got != "u" {
|
||||
t.Errorf("the key's owner: %q", got)
|
||||
}
|
||||
if got := one(`SELECT key_id FROM key_claims`); got != "k" {
|
||||
t.Errorf("the claim lost its key: %q", got)
|
||||
}
|
||||
if got := one(`SELECT scope_type || ':' || scope_id || ':' || role || ':' || added_by FROM memberships WHERE user_id = 'u'`); got != "project:p:member:admin@x" {
|
||||
t.Errorf("the person's project did not become a membership: %q", got)
|
||||
}
|
||||
if got := one(`SELECT COUNT(*) FROM memberships WHERE user_id = 'w'`); got != "0" {
|
||||
t.Error("a pending signup was given a membership")
|
||||
}
|
||||
var users []string
|
||||
rows, _ := db.QueryContext(ctx, `SELECT key_id || '=' || user_id FROM usage ORDER BY ts`)
|
||||
for rows.Next() {
|
||||
var s string
|
||||
_ = rows.Scan(&s)
|
||||
users = append(users, s)
|
||||
}
|
||||
rows.Close()
|
||||
if strings.Join(users, ",") != "k=u,session:u=u,ops=" {
|
||||
t.Errorf("usage attributed as %v", users)
|
||||
}
|
||||
// The rebuilt table takes a personal key, and still refuses a project
|
||||
// that does not exist.
|
||||
if _, err := db.ExecContext(ctx, `INSERT INTO api_keys (id, key_hash, key_prefix, name, created_at, user_id)
|
||||
VALUES ('pk', X'03', 'sk-3', 'mine', 1, 'u')`); err != nil {
|
||||
t.Errorf("a personal key was refused: %v", err)
|
||||
}
|
||||
if _, err := db.ExecContext(ctx, `INSERT INTO api_keys (id, key_hash, key_prefix, name, project_id, created_at)
|
||||
VALUES ('bad', X'04', 'sk-4', 'x', 'nope', 1)`); err == nil {
|
||||
t.Error("the rebuilt table lost its foreign key to projects")
|
||||
}
|
||||
fk, err := db.QueryContext(ctx, `PRAGMA foreign_key_check`)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if fk.Next() {
|
||||
t.Error("foreign keys are violated after the migration")
|
||||
}
|
||||
fk.Close()
|
||||
// And they are back on for everything after it.
|
||||
if one(`PRAGMA foreign_keys`) != "1" {
|
||||
t.Error("the migration left foreign keys off")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
-- A person could be in exactly one project, chosen once at approval, and could
|
||||
-- not use the gateway at all before that. People belong to several teams and
|
||||
-- to none, so membership becomes its own table and a key need not have a
|
||||
-- project: a personal key is owned by a person and bounded by that person's
|
||||
-- own limits.
|
||||
|
||||
-- Membership at any level of the tree; a member of a team may use every
|
||||
-- project in it. Role is 'member' today; 'manager' is reserved for delegated
|
||||
-- administration of the scope.
|
||||
CREATE TABLE memberships (
|
||||
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
scope_type TEXT NOT NULL,
|
||||
scope_id TEXT NOT NULL,
|
||||
role TEXT NOT NULL DEFAULT 'member',
|
||||
added_at BIGINT NOT NULL,
|
||||
added_by TEXT,
|
||||
PRIMARY KEY (user_id, scope_type, scope_id)
|
||||
);
|
||||
CREATE INDEX memberships_by_scope ON memberships(scope_type, scope_id);
|
||||
|
||||
-- Everybody keeps the project they had.
|
||||
INSERT INTO memberships (user_id, scope_type, scope_id, role, added_at, added_by)
|
||||
SELECT id, 'project', project_id, 'member', COALESCE(approved_at, created_at), approved_by
|
||||
FROM users WHERE project_id IS NOT NULL;
|
||||
|
||||
-- A personal key has an owner and no project.
|
||||
ALTER TABLE api_keys ALTER COLUMN project_id DROP NOT NULL;
|
||||
|
||||
-- Who spent it, recorded with the spend. Deriving it from the key at read time
|
||||
-- counted a key's past against whoever owns it now, and could not attribute
|
||||
-- the chat page's requests, which have no key row at all.
|
||||
ALTER TABLE usage ADD COLUMN user_id TEXT NOT NULL DEFAULT '';
|
||||
UPDATE usage SET user_id = COALESCE((SELECT k.user_id FROM api_keys k WHERE k.id = usage.key_id), '');
|
||||
UPDATE usage SET user_id = substr(key_id, 9) WHERE key_id LIKE 'session:%';
|
||||
CREATE INDEX usage_by_user_ts ON usage(user_id, ts);
|
||||
@@ -0,0 +1,60 @@
|
||||
-- A person could be in exactly one project, chosen once at approval, and could
|
||||
-- not use the gateway at all before that. People belong to several teams and
|
||||
-- to none, so membership becomes its own table and a key need not have a
|
||||
-- project: a personal key is owned by a person and bounded by that person's
|
||||
-- own limits.
|
||||
|
||||
-- Membership at any level of the tree; a member of a team may use every
|
||||
-- project in it. Role is 'member' today; 'manager' is reserved for delegated
|
||||
-- administration of the scope.
|
||||
CREATE TABLE memberships (
|
||||
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
scope_type TEXT NOT NULL,
|
||||
scope_id TEXT NOT NULL,
|
||||
role TEXT NOT NULL DEFAULT 'member',
|
||||
added_at INTEGER NOT NULL,
|
||||
added_by TEXT,
|
||||
PRIMARY KEY (user_id, scope_type, scope_id)
|
||||
);
|
||||
CREATE INDEX memberships_by_scope ON memberships(scope_type, scope_id);
|
||||
|
||||
-- Everybody keeps the project they had.
|
||||
INSERT INTO memberships (user_id, scope_type, scope_id, role, added_at, added_by)
|
||||
SELECT id, 'project', project_id, 'member', COALESCE(approved_at, created_at), approved_by
|
||||
FROM users WHERE project_id IS NOT NULL;
|
||||
|
||||
-- A personal key has an owner and no project. SQLite cannot drop NOT NULL
|
||||
-- from a column, so the table is rebuilt — with foreign keys off while it is,
|
||||
-- as SQLite's own procedure for this requires, and checked before commit.
|
||||
-- migrate: foreign_keys=off
|
||||
CREATE TABLE api_keys_new (
|
||||
id TEXT PRIMARY KEY,
|
||||
key_hash BLOB NOT NULL UNIQUE,
|
||||
key_prefix TEXT NOT NULL,
|
||||
name TEXT NOT NULL,
|
||||
project_id TEXT REFERENCES projects(id),
|
||||
band TEXT,
|
||||
routing_profile TEXT,
|
||||
created_at INTEGER NOT NULL,
|
||||
expires_at INTEGER,
|
||||
revoked_at INTEGER,
|
||||
last_used_at INTEGER,
|
||||
user_id TEXT REFERENCES users(id)
|
||||
);
|
||||
INSERT INTO api_keys_new (id, key_hash, key_prefix, name, project_id, band, routing_profile,
|
||||
created_at, expires_at, revoked_at, last_used_at, user_id)
|
||||
SELECT id, key_hash, key_prefix, name, project_id, band, routing_profile,
|
||||
created_at, expires_at, revoked_at, last_used_at, user_id
|
||||
FROM api_keys;
|
||||
DROP TABLE api_keys;
|
||||
ALTER TABLE api_keys_new RENAME TO api_keys;
|
||||
CREATE INDEX api_keys_by_project ON api_keys(project_id);
|
||||
CREATE INDEX api_keys_by_user ON api_keys(user_id);
|
||||
|
||||
-- Who spent it, recorded with the spend. Deriving it from the key at read time
|
||||
-- counted a key's past against whoever owns it now, and could not attribute
|
||||
-- the chat page's requests, which have no key row at all.
|
||||
ALTER TABLE usage ADD COLUMN user_id TEXT NOT NULL DEFAULT '';
|
||||
UPDATE usage SET user_id = COALESCE((SELECT k.user_id FROM api_keys k WHERE k.id = usage.key_id), '');
|
||||
UPDATE usage SET user_id = substr(key_id, 9) WHERE key_id LIKE 'session:%';
|
||||
CREATE INDEX usage_by_user_ts ON usage(user_id, ts);
|
||||
@@ -0,0 +1,87 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// The membership queries on PostgreSQL: the unions that decide which projects
|
||||
// a person may use, the path each membership is named by, the revocation that
|
||||
// follows leaving, a personal key's resolution, and spend with no project.
|
||||
// Each passed on SQLite first; these are what would catch one that does not
|
||||
// on the database the cluster runs.
|
||||
func TestPostgresMemberships(t *testing.T) {
|
||||
f := newFixtureOn(t, openPG(t))
|
||||
ctx := t.Context()
|
||||
|
||||
if err := f.s.AddMembership(ctx, f.user, ScopeTeam, f.ml, RoleMember, "t", time.Now()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := f.s.AddMembership(ctx, f.user, ScopeTeam, f.ml, RoleMember, "t", time.Now()); err != nil {
|
||||
t.Errorf("adding again should change nothing: %v", err)
|
||||
}
|
||||
for proj, want := range map[string]bool{f.gateway: true, f.research: true, f.search: false} {
|
||||
if ok, err := f.s.CanUseProject(ctx, f.user, proj); err != nil || ok != want {
|
||||
t.Errorf("CanUseProject %s = %v, %v; want %v", proj, ok, err, want)
|
||||
}
|
||||
}
|
||||
if ps, err := f.s.ProjectsFor(ctx, f.user); err != nil || len(ps) != 2 {
|
||||
t.Errorf("ProjectsFor = %+v, %v", ps, err)
|
||||
}
|
||||
ms, err := f.s.MembershipsOf(ctx, f.user)
|
||||
if err != nil || len(ms) != 2 || ms[0].Path != "Acme / platform / gateway" || ms[1].Path != "Scania / ml" {
|
||||
t.Errorf("MembershipsOf = %+v, %v", ms, err)
|
||||
}
|
||||
if all, err := f.s.AllMemberships(ctx); err != nil || len(all) != 2 {
|
||||
t.Errorf("AllMemberships = %+v, %v", all, err)
|
||||
}
|
||||
|
||||
// Leaving gateway revokes the key made there, and leaves a personal one.
|
||||
_, personal, _ := NewKey("key-p", "personal", "")
|
||||
if err := f.s.CreateUserKey(ctx, f.user, personal); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if n, err := f.s.RemoveMembership(ctx, f.user, ScopeProject, f.gateway, time.Now()); err != nil || n != 1 {
|
||||
t.Errorf("RemoveMembership revoked %d, %v; want 1", n, err)
|
||||
}
|
||||
|
||||
// A personal key resolves, under the personal defaults.
|
||||
f.s.SetPersonalDefaults(&Limits{RPM: i(9)})
|
||||
defer f.s.SetPersonalDefaults(nil)
|
||||
e, err := f.s.Resolve(ctx, personal.ID)
|
||||
if err != nil || e.UserID != f.user || e.ProjectID != "" || e.RPM == nil || *e.RPM != 9 {
|
||||
t.Errorf("personal key resolved to %+v, %v", e, err)
|
||||
}
|
||||
if e, err := f.s.ResolveFor(ctx, "session:"+f.user, f.user, f.research); err != nil || e.OrgID != f.scania {
|
||||
t.Errorf("ResolveFor in a project = %+v, %v", e, err)
|
||||
}
|
||||
|
||||
// Spend with no project is kept, and attributed.
|
||||
now := time.Now()
|
||||
if err := f.s.WriteUsage(ctx, []Usage{
|
||||
{At: now, KeyID: personal.ID, UserID: f.user, CostMicros: 5, Model: "m", ServedModel: "m"},
|
||||
{At: now, KeyID: "session:" + f.user, UserID: f.user, ProjectID: f.research, CostMicros: 7, Model: "m", ServedModel: "m"},
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rows, err := f.s.SpendSinceByScope(ctx, now.Add(-time.Minute))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var total int64
|
||||
for _, r := range rows {
|
||||
if r.UserID == f.user {
|
||||
total += r.Micros
|
||||
}
|
||||
}
|
||||
if total != 12 {
|
||||
t.Errorf("restored %d for the person, want 12: %+v", total, rows)
|
||||
}
|
||||
byUser, err := f.s.UsageByUser(ctx, now.Add(-time.Minute))
|
||||
if err != nil || len(byUser) != 1 || byUser[0].UserID != f.user || byUser[0].Requests != 2 {
|
||||
t.Errorf("UsageByUser = %+v, %v", byUser, err)
|
||||
}
|
||||
if keys, err := f.s.AllKeys(ctx); err != nil || len(keys) != 3 {
|
||||
t.Errorf("AllKeys = %d rows, %v", len(keys), err)
|
||||
}
|
||||
}
|
||||
@@ -41,7 +41,7 @@ func openPG(t *testing.T) *DB {
|
||||
// inherits the previous one's lease is refused for reasons that have
|
||||
// nothing to do with what it is testing. It passed on SQLite, where
|
||||
// every subtest gets a fresh file, and failed only here.
|
||||
`TRUNCATE thread_messages, threads, memory_notes, usage, api_keys,
|
||||
`TRUNCATE thread_messages, threads, memory_notes, usage, api_keys, memberships,
|
||||
key_claims, limits, models, sessions, users, projects, teams,
|
||||
organizations, leadership RESTART IDENTITY CASCADE`)
|
||||
if err != nil {
|
||||
|
||||
+27
-72
@@ -40,6 +40,9 @@ type DB struct {
|
||||
mu sync.RWMutex
|
||||
defaultRPM *int
|
||||
defaultTPM *int
|
||||
// personal is what a person's own use is held to when nobody wrote a
|
||||
// limit for them; see SetPersonalDefaults.
|
||||
personal *Limits
|
||||
}
|
||||
|
||||
// OpenSQLite opens (creating if needed) a database and brings it up to date.
|
||||
@@ -157,7 +160,7 @@ func (s *DB) Projects(ctx context.Context, teamID string) ([]Project, error) {
|
||||
// --- keys ---
|
||||
|
||||
const keyColumns = `id, key_hash, key_prefix, name, project_id, band, routing_profile,
|
||||
created_at, expires_at, revoked_at, last_used_at`
|
||||
created_at, expires_at, revoked_at, last_used_at, user_id`
|
||||
|
||||
// CreateKey stores a key. Only its hash is written; the key itself is the
|
||||
// caller's to show once and then forget.
|
||||
@@ -166,10 +169,11 @@ func (s *DB) CreateKey(ctx context.Context, k Key) error {
|
||||
return errors.New("store: a key needs a hash")
|
||||
}
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`INSERT INTO api_keys (`+keyColumns+`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
k.ID, k.Hash, k.Prefix, k.Name, k.ProjectID,
|
||||
`INSERT INTO api_keys (`+keyColumns+`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
k.ID, k.Hash, k.Prefix, k.Name, nullString(k.ProjectID),
|
||||
nullString(k.Band), nullString(k.RoutingProfile),
|
||||
millis(k.CreatedAt), nullMillis(k.ExpiresAt), nullMillis(k.RevokedAt), nullMillis(k.LastUsedAt))
|
||||
millis(k.CreatedAt), nullMillis(k.ExpiresAt), nullMillis(k.RevokedAt), nullMillis(k.LastUsedAt),
|
||||
nullString(k.UserID))
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -295,56 +299,6 @@ func (s *DB) LimitsFor(ctx context.Context, scope Scope, id string) (Limits, err
|
||||
return l, nil
|
||||
}
|
||||
|
||||
// Resolve walks a key's chain and returns the most restrictive of each limit.
|
||||
//
|
||||
// One query rather than four lookups: the chain is a fixed three-level join, and
|
||||
// this is called on a cache miss during authentication.
|
||||
func (s *DB) Resolve(ctx context.Context, keyID string) (Effective, error) {
|
||||
var e Effective
|
||||
row := s.db.QueryRowContext(ctx,
|
||||
`SELECT k.id, k.band, k.routing_profile, p.id, t.id, o.id
|
||||
FROM api_keys k
|
||||
JOIN projects p ON p.id = k.project_id
|
||||
JOIN teams t ON t.id = p.team_id
|
||||
JOIN organizations o ON o.id = t.org_id
|
||||
WHERE k.id = ?`, keyID)
|
||||
|
||||
var band, profile sql.NullString
|
||||
if err := row.Scan(&e.KeyID, &band, &profile, &e.ProjectID, &e.TeamID, &e.OrgID); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return Effective{}, ErrNotFound
|
||||
}
|
||||
return Effective{}, err
|
||||
}
|
||||
e.Band, e.RoutingProfile = band.String, profile.String
|
||||
|
||||
// Widest first, so a narrower scope can only tighten what it inherits.
|
||||
chain := []struct {
|
||||
scope Scope
|
||||
id string
|
||||
}{
|
||||
{ScopeOrg, e.OrgID},
|
||||
{ScopeTeam, e.TeamID},
|
||||
{ScopeProject, e.ProjectID},
|
||||
{ScopeKey, e.KeyID},
|
||||
}
|
||||
for _, step := range chain {
|
||||
l, err := s.LimitsFor(ctx, step.scope, step.id)
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return Effective{}, err
|
||||
}
|
||||
e.tighten(l)
|
||||
// Kept whole as well as folded in. Enforcement walks this; the folded
|
||||
// values are for showing somebody their ceiling.
|
||||
e.Chain = append(e.Chain, l)
|
||||
}
|
||||
s.applyDefaults(&e)
|
||||
return e, nil
|
||||
}
|
||||
|
||||
// SetDefaultLimits sets what applies to a key no scope gives a limit to.
|
||||
//
|
||||
// A default is a fallback, not a ceiling, so it is applied after the chain and
|
||||
@@ -390,17 +344,18 @@ func (s *DB) applyDefaults(e *Effective) {
|
||||
}
|
||||
}
|
||||
|
||||
// SpendSinceByScope totals cost per key, with the key's place in the tree.
|
||||
// SpendSinceByScope totals cost per key and person, with the key's place in
|
||||
// the tree. Personal keys and the chat page's requests have no project and are
|
||||
// kept: dropping them is what would reset a person's budget on every restart.
|
||||
func (s *DB) SpendSinceByScope(ctx context.Context, since time.Time) ([]ScopeSpend, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT k.id, p.id, t.id, o.id, SUM(u.cost_micros)
|
||||
`SELECT u.key_id, u.user_id, COALESCE(p.id, ''), COALESCE(t.id, ''), COALESCE(t.org_id, ''),
|
||||
SUM(u.cost_micros)
|
||||
FROM usage u
|
||||
JOIN api_keys k ON k.id = u.key_id
|
||||
JOIN projects p ON p.id = k.project_id
|
||||
JOIN teams t ON t.id = p.team_id
|
||||
JOIN organizations o ON o.id = t.org_id
|
||||
LEFT JOIN projects p ON p.id = NULLIF(u.project_id, '')
|
||||
LEFT JOIN teams t ON t.id = p.team_id
|
||||
WHERE u.ts >= ?
|
||||
GROUP BY k.id, p.id, t.id, o.id`, millis(since))
|
||||
GROUP BY u.key_id, u.user_id, p.id, t.id, t.org_id`, millis(since))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -410,7 +365,7 @@ func (s *DB) SpendSinceByScope(ctx context.Context, since time.Time) ([]ScopeSpe
|
||||
for rows.Next() {
|
||||
var sp ScopeSpend
|
||||
var total sql.NullInt64
|
||||
if err := rows.Scan(&sp.KeyID, &sp.ProjectID, &sp.TeamID, &sp.OrgID, &total); err != nil {
|
||||
if err := rows.Scan(&sp.KeyID, &sp.UserID, &sp.ProjectID, &sp.TeamID, &sp.OrgID, &total); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
sp.Micros = total.Int64
|
||||
@@ -469,8 +424,8 @@ func (s *DB) WriteUsage(ctx context.Context, records []Usage) error {
|
||||
return s.inTx(ctx, func(tx conn) error {
|
||||
stmt, err := tx.PrepareContext(ctx,
|
||||
`INSERT INTO usage (ts, key_id, project_id, model, served_model,
|
||||
prompt_tokens, completion_tokens, cost_micros, status, latency_ms)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
|
||||
prompt_tokens, completion_tokens, cost_micros, status, latency_ms, user_id)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -478,7 +433,7 @@ func (s *DB) WriteUsage(ctx context.Context, records []Usage) error {
|
||||
for _, r := range records {
|
||||
if _, err := stmt.ExecContext(ctx, millis(r.At), r.KeyID, r.ProjectID,
|
||||
r.Model, r.ServedModel, r.PromptTokens, r.CompletionTokens,
|
||||
r.CostMicros, r.Status, r.LatencyMs); err != nil {
|
||||
r.CostMicros, r.Status, r.LatencyMs, r.UserID); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -539,13 +494,14 @@ type scanner interface{ Scan(...any) error }
|
||||
|
||||
func scanKey(sc scanner) (Key, error) {
|
||||
var k Key
|
||||
var band, profile sql.NullString
|
||||
var band, profile, project, user sql.NullString
|
||||
var expires, revoked, lastUsed sql.NullInt64
|
||||
var created int64
|
||||
if err := sc.Scan(&k.ID, &k.Hash, &k.Prefix, &k.Name, &k.ProjectID,
|
||||
&band, &profile, &created, &expires, &revoked, &lastUsed); err != nil {
|
||||
if err := sc.Scan(&k.ID, &k.Hash, &k.Prefix, &k.Name, &project,
|
||||
&band, &profile, &created, &expires, &revoked, &lastUsed, &user); err != nil {
|
||||
return Key{}, err
|
||||
}
|
||||
k.ProjectID, k.UserID = project.String, user.String
|
||||
k.Band, k.RoutingProfile = band.String, profile.String
|
||||
k.CreatedAt = fromMillis(created)
|
||||
k.ExpiresAt = fromNullMillis(expires)
|
||||
@@ -770,22 +726,21 @@ func (u UserUsage) Tokens() int64 { return u.Prompt + u.Completion }
|
||||
// existed — are grouped under an empty user, which is honest rather than tidy.
|
||||
func (s *DB) UsageByUser(ctx context.Context, since time.Time) ([]UserUsage, error) {
|
||||
rows, err := s.db.QueryContext(ctx, `
|
||||
SELECT COALESCE(k.user_id, ''), COALESCE(us.email, ''), COALESCE(us.name, ''),
|
||||
SELECT u.user_id, COALESCE(us.email, ''), COALESCE(us.name, ''),
|
||||
COUNT(DISTINCT u.key_id),
|
||||
COUNT(*), SUM(u.prompt_tokens), SUM(u.completion_tokens),
|
||||
SUM(u.cost_micros),
|
||||
SUM(CASE WHEN u.status >= 400 THEN 1 ELSE 0 END),
|
||||
MAX(u.ts)
|
||||
FROM usage u
|
||||
LEFT JOIN api_keys k ON k.id = u.key_id
|
||||
LEFT JOIN users us ON us.id = k.user_id
|
||||
LEFT JOIN users us ON us.id = NULLIF(u.user_id, '')
|
||||
WHERE u.ts >= ?
|
||||
-- Every selected column that is not an aggregate has to be grouped.
|
||||
-- SQLite picks an arbitrary row for the rest and carries on; PostgreSQL
|
||||
-- refuses, so this query worked in tests and returned nothing but an
|
||||
-- error on the cluster. The email and name are functionally dependent
|
||||
-- on the user id, so grouping by them changes no result.
|
||||
GROUP BY COALESCE(k.user_id, ''), COALESCE(us.email, ''), COALESCE(us.name, '')
|
||||
GROUP BY u.user_id, COALESCE(us.email, ''), COALESCE(us.name, '')
|
||||
ORDER BY SUM(u.cost_micros) DESC, COUNT(*) DESC`, millis(since))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
||||
+41
-1
@@ -32,8 +32,38 @@ const (
|
||||
ScopeTeam Scope = "team"
|
||||
ScopeProject Scope = "project"
|
||||
ScopeKey Scope = "key"
|
||||
|
||||
// ScopeUser is a person, across every key they own and every project they
|
||||
// use: "Ayşe may spend at most this, wherever she spends it".
|
||||
ScopeUser Scope = "user"
|
||||
|
||||
// The member scopes are a limit written on an org, team or project that
|
||||
// applies to each member separately: "each member of this project gets at
|
||||
// most this here". The limit is stored under the scope's own id; each
|
||||
// member's use is counted under that id and theirs, see MemberOwner.
|
||||
ScopeOrgMember Scope = "org-member"
|
||||
ScopeTeamMember Scope = "team-member"
|
||||
ScopeProjectMember Scope = "project-member"
|
||||
)
|
||||
|
||||
// MemberScope is the per-member scope for a level of the tree, or "".
|
||||
func MemberScope(level Scope) Scope {
|
||||
switch level {
|
||||
case ScopeOrg:
|
||||
return ScopeOrgMember
|
||||
case ScopeTeam:
|
||||
return ScopeTeamMember
|
||||
case ScopeProject:
|
||||
return ScopeProjectMember
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// MemberOwner is the counter one member's use of a per-member limit goes to.
|
||||
func MemberOwner(scope Scope, scopeID, userID string) LimitOwner {
|
||||
return LimitOwner{Scope: scope, ID: scopeID + "/" + userID}
|
||||
}
|
||||
|
||||
// Org, Team and Project are the tenancy tree.
|
||||
type Org struct {
|
||||
ID, Name string
|
||||
@@ -52,6 +82,8 @@ type Project struct {
|
||||
// Key is an API key as stored: never the key itself.
|
||||
type Key struct {
|
||||
ID string
|
||||
// UserID owns the key; empty for one an operator issued in a project.
|
||||
UserID string
|
||||
// Hash is sha256 of the key, and the only copy of anything derived from it.
|
||||
Hash []byte
|
||||
// Prefix is shown in listings so a key can be identified without revealing
|
||||
@@ -114,7 +146,10 @@ const (
|
||||
// A team cannot raise a limit its organization set, which is the only
|
||||
// composition rule under which a budget means anything.
|
||||
type Effective struct {
|
||||
KeyID string
|
||||
KeyID string
|
||||
// UserID is the key's owner, empty for a key an operator issued in a
|
||||
// project. A personal key has an owner and no project.
|
||||
UserID string
|
||||
ProjectID string
|
||||
TeamID string
|
||||
OrgID string
|
||||
@@ -192,6 +227,10 @@ func (e Effective) Allows(model string) bool {
|
||||
type Usage struct {
|
||||
At time.Time
|
||||
KeyID string
|
||||
// UserID is who spent it, empty for a key with no owner. Recorded with the
|
||||
// spend rather than looked up from the key later, so a key's past is not
|
||||
// moved onto whoever owns it next.
|
||||
UserID string
|
||||
// ProjectID is denormalized so reporting does not join on every row, and so
|
||||
// a row stays meaningful if the key is later revoked.
|
||||
ProjectID string
|
||||
@@ -287,6 +326,7 @@ type Bucket struct {
|
||||
// does. One query, and the folding happens where it can be tested.
|
||||
type ScopeSpend struct {
|
||||
KeyID string
|
||||
UserID string
|
||||
ProjectID string
|
||||
TeamID string
|
||||
OrgID string
|
||||
|
||||
@@ -86,12 +86,12 @@ var groupColumns = map[Grouping]struct{ id, name, joins string }{
|
||||
GroupByProject: {"p.id", "p.name", `
|
||||
JOIN api_keys k ON k.id = u.key_id
|
||||
JOIN projects p ON p.id = k.project_id`},
|
||||
// Left joins, and coalesced: a key issued by an operator before accounts
|
||||
// existed has no owner, and its traffic is real. It groups under an empty
|
||||
// id, which the page names rather than hides.
|
||||
GroupByUser: {"COALESCE(k.user_id, '')", "COALESCE(us.email, '')", `
|
||||
LEFT JOIN api_keys k ON k.id = u.key_id
|
||||
LEFT JOIN users us ON us.id = k.user_id`},
|
||||
// Who spent it, as recorded with the spend — which includes personal keys
|
||||
// and the chat page, neither of which a key's project reaches. Traffic
|
||||
// from keys with no owner groups under an empty id, which the page names
|
||||
// rather than hides.
|
||||
GroupByUser: {"u.user_id", "COALESCE(us.email, '')", `
|
||||
LEFT JOIN users us ON us.id = NULLIF(u.user_id, '')`},
|
||||
}
|
||||
|
||||
// UsageBucketsBy returns each group's usage over time.
|
||||
|
||||
+43
-71
@@ -98,39 +98,45 @@ func (s *DB) Users(ctx context.Context, state UserState) ([]User, error) {
|
||||
})
|
||||
}
|
||||
|
||||
// ApproveUser activates an account and places it in a project.
|
||||
// ApproveUser activates an account, and puts it in a project when one is given.
|
||||
//
|
||||
// The project is required: an approved account with nowhere to put its keys
|
||||
// would pass every check and then fail at the first key it tried to make.
|
||||
// A project is not required: a person need not belong to anything to use the
|
||||
// gateway on their own, bounded by their personal limits. Memberships can be
|
||||
// added at approval or at any time after.
|
||||
func (s *DB) ApproveUser(ctx context.Context, id, projectID, by string, at time.Time) error {
|
||||
if projectID == "" {
|
||||
return errors.New("approving an account needs a project for its keys")
|
||||
}
|
||||
res, err := s.db.ExecContext(ctx,
|
||||
`UPDATE users SET state = ?, project_id = ?, approved_at = ?, approved_by = ?
|
||||
WHERE id = ? AND state = ?`,
|
||||
string(UserActive), projectID, millis(at), by, id, string(UserPending))
|
||||
if err != nil {
|
||||
return s.inTx(ctx, func(c conn) error {
|
||||
res, err := c.ExecContext(ctx,
|
||||
`UPDATE users SET state = ?, approved_at = ?, approved_by = ? WHERE id = ? AND state = ?`,
|
||||
string(UserActive), millis(at), by, id, string(UserPending))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if n, _ := res.RowsAffected(); n == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
if projectID == "" {
|
||||
return nil
|
||||
}
|
||||
_, err = c.ExecContext(ctx, `
|
||||
INSERT INTO memberships (user_id, scope_type, scope_id, role, added_at, added_by)
|
||||
VALUES (?, 'project', ?, 'member', ?, ?)
|
||||
ON CONFLICT (user_id, scope_type, scope_id) DO NOTHING`,
|
||||
id, projectID, millis(at), nullString(by))
|
||||
return err
|
||||
}
|
||||
if n, _ := res.RowsAffected(); n == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// SetUserState suspends or reinstates an account.
|
||||
//
|
||||
// An account with no project cannot be made active. A pending account that
|
||||
// was rejected and then reinstated used to become exactly that: able to sign
|
||||
// in, and failing with "something went wrong" at the first key it made.
|
||||
// Approving is what gives it a project.
|
||||
// Only an account that was once approved can be reinstated. Otherwise a
|
||||
// signup suspended while pending and then reinstated would become active
|
||||
// without anybody approving it.
|
||||
func (s *DB) SetUserState(ctx context.Context, id string, state UserState) error {
|
||||
if state == UserActive {
|
||||
var project sql.NullString
|
||||
if err := s.db.QueryRowContext(ctx, `SELECT project_id FROM users WHERE id = ?`, id).
|
||||
Scan(&project); err == nil && !project.Valid {
|
||||
return errors.New("this account has no project; approve it into one instead")
|
||||
var approved sql.NullInt64
|
||||
if err := s.db.QueryRowContext(ctx, `SELECT approved_at FROM users WHERE id = ?`, id).
|
||||
Scan(&approved); err == nil && !approved.Valid {
|
||||
return errors.New("this account was never approved; approve it instead")
|
||||
}
|
||||
}
|
||||
res, err := s.db.ExecContext(ctx, `UPDATE users SET state = ? WHERE id = ?`, string(state), id)
|
||||
@@ -175,17 +181,21 @@ func (s *DB) KeysForUser(ctx context.Context, userID string) ([]Key, error) {
|
||||
}
|
||||
|
||||
// CreateUserKey issues a key owned by a person.
|
||||
//
|
||||
// With a project, the key is used there and the person must be able to use
|
||||
// that project; without one it is personal, bounded by the person's own limits.
|
||||
func (s *DB) CreateUserKey(ctx context.Context, userID string, k Key) error {
|
||||
if len(k.Hash) == 0 {
|
||||
return errors.New("store: a key needs a hash")
|
||||
if k.ProjectID != "" {
|
||||
ok, err := s.CanUseProject(ctx, userID, k.ProjectID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !ok {
|
||||
return ErrNotMember
|
||||
}
|
||||
}
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`INSERT INTO api_keys (`+keyColumns+`, user_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
k.ID, k.Hash, k.Prefix, k.Name, k.ProjectID,
|
||||
nullString(k.Band), nullString(k.RoutingProfile),
|
||||
millis(k.CreatedAt), nullMillis(k.ExpiresAt), nullMillis(k.RevokedAt),
|
||||
nullMillis(k.LastUsedAt), userID)
|
||||
return err
|
||||
k.UserID = userID
|
||||
return s.CreateKey(ctx, k)
|
||||
}
|
||||
|
||||
// RevokeUserKey revokes a key only if it belongs to this person.
|
||||
@@ -268,41 +278,3 @@ func (s *DB) AllProjects(ctx context.Context) ([]ProjectPath, error) {
|
||||
type ProjectPath struct {
|
||||
ID, Path string
|
||||
}
|
||||
|
||||
// ResolveProject returns the limits an account inherits from its project.
|
||||
//
|
||||
// The same walk as Resolve, minus the key. A person signed in to the chat page
|
||||
// has no key in their hand — the key was shown once and is theirs to keep — so
|
||||
// their identity there is their project, and it must be resolved the same way
|
||||
// or the page would be a hole in the limits everything else obeys.
|
||||
func (s *DB) ResolveProject(ctx context.Context, projectID string) (Effective, error) {
|
||||
var e Effective
|
||||
row := s.db.QueryRowContext(ctx,
|
||||
`SELECT p.id, t.id, o.id
|
||||
FROM projects p
|
||||
JOIN teams t ON t.id = p.team_id
|
||||
JOIN organizations o ON o.id = t.org_id
|
||||
WHERE p.id = ?`, projectID)
|
||||
if err := row.Scan(&e.ProjectID, &e.TeamID, &e.OrgID); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return Effective{}, ErrNotFound
|
||||
}
|
||||
return Effective{}, err
|
||||
}
|
||||
|
||||
// Widest first, so a narrower scope can only tighten what it inherits.
|
||||
for _, step := range []struct {
|
||||
scope Scope
|
||||
id string
|
||||
}{{ScopeOrg, e.OrgID}, {ScopeTeam, e.TeamID}, {ScopeProject, e.ProjectID}} {
|
||||
l, err := s.LimitsFor(ctx, step.scope, step.id)
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return Effective{}, err
|
||||
}
|
||||
e.tighten(l)
|
||||
}
|
||||
return e, nil
|
||||
}
|
||||
+88
-25
@@ -38,6 +38,10 @@ type KeyOwner interface {
|
||||
RevokeUserKey(ctx context.Context, userID, keyID string, at time.Time) error
|
||||
Resolve(ctx context.Context, keyID string) (store.Effective, error)
|
||||
LimitsFor(ctx context.Context, scope store.Scope, id string) (store.Limits, error)
|
||||
// Where a person may make keys, and what applies there.
|
||||
ProjectsFor(ctx context.Context, userID string) ([]store.ProjectPath, error)
|
||||
MembershipsOf(ctx context.Context, userID string) ([]store.Membership, error)
|
||||
ResolveFor(ctx context.Context, callerID, userID, projectID string) (store.Effective, error)
|
||||
}
|
||||
|
||||
// AccountPages serves signup, sign-in and the profile.
|
||||
@@ -57,6 +61,10 @@ type AccountPages struct {
|
||||
hasMirror bool
|
||||
// hasQuotas is set when /admin/quotas is registered.
|
||||
hasQuotas bool
|
||||
// personalOff refuses personal keys; see SetPersonalOff.
|
||||
personalOff bool
|
||||
// personalDefaults is what personal use falls under by default.
|
||||
personalDefaults *store.Limits
|
||||
// priced says whether a budget can ever be spent against.
|
||||
priced Priced
|
||||
// registry browses a model registry, or is nil where there is no way out.
|
||||
@@ -216,13 +224,26 @@ func (p *AccountPages) logout(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
type limitRow struct{ Name, Value string }
|
||||
|
||||
// contextLimits is what applies to a person in one place they can spend.
|
||||
type contextLimits struct {
|
||||
Label string
|
||||
Rows []limitRow
|
||||
}
|
||||
|
||||
type profileData struct {
|
||||
Nav Nav
|
||||
User store.User
|
||||
Keys []store.Key
|
||||
Limits []limitRow
|
||||
NewKey string
|
||||
Error string
|
||||
Nav Nav
|
||||
// Contexts are where a key can be made: the person's projects, and
|
||||
// themselves when personal use is on.
|
||||
Contexts []ChatContext
|
||||
// Where names each key's project by path; a personal key has none.
|
||||
Where map[string]string
|
||||
Memberships []store.Membership
|
||||
LimitsBy []contextLimits
|
||||
User store.User
|
||||
Keys []store.Key
|
||||
Limits []limitRow
|
||||
NewKey string
|
||||
Error string
|
||||
|
||||
PasswordChanged bool
|
||||
PasswordError string
|
||||
@@ -263,7 +284,15 @@ func (p *AccountPages) createKey(w http.ResponseWriter, r *http.Request) {
|
||||
if name == "" {
|
||||
name = "untitled"
|
||||
}
|
||||
secret, k, err := store.NewKey(randomKeyID(), name, user.ProjectID)
|
||||
project := r.FormValue("context")
|
||||
if project == personalValue {
|
||||
if p.personalOff {
|
||||
p.renderProfile(w, r, sess, user, "", "personal keys are off on this gateway; choose a project")
|
||||
return
|
||||
}
|
||||
project = ""
|
||||
}
|
||||
secret, k, err := store.NewKey(randomKeyID(), name, project)
|
||||
if err != nil {
|
||||
p.log.Error("could not mint a key", "err", err)
|
||||
p.renderProfile(w, r, sess, user, "", "something went wrong; try again")
|
||||
@@ -271,6 +300,10 @@ func (p *AccountPages) createKey(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
k.CreatedAt = time.Now()
|
||||
if err := p.keys.CreateUserKey(r.Context(), user.ID, k); err != nil {
|
||||
if errors.Is(err, store.ErrNotMember) {
|
||||
p.renderProfile(w, r, sess, user, "", "you are not a member of that project")
|
||||
return
|
||||
}
|
||||
p.log.Error("could not store a key", "err", err)
|
||||
p.renderProfile(w, r, sess, user, "", "something went wrong; try again")
|
||||
return
|
||||
@@ -331,34 +364,64 @@ func (p *AccountPages) render(w http.ResponseWriter, r *http.Request,
|
||||
p.log.Error("could not list keys", "err", err)
|
||||
}
|
||||
d.Keys = keys
|
||||
d.Limits = p.limitsFor(r.Context(), user)
|
||||
p.fillPlaces(r.Context(), user, &d)
|
||||
render(w, "profile", d)
|
||||
}
|
||||
|
||||
// limitsFor renders the limits a person's keys inherit from their project.
|
||||
//
|
||||
// From the project rather than from a key, because a person with no keys yet
|
||||
// still wants to know what they are getting.
|
||||
func (p *AccountPages) limitsFor(ctx context.Context, user store.User) []limitRow {
|
||||
l, err := p.keys.LimitsFor(ctx, store.ScopeProject, user.ProjectID)
|
||||
// personalValue is how a form names the person's own, project-less use.
|
||||
const personalValue = "personal"
|
||||
|
||||
// SetPersonalOff says personal keys are refused on this gateway.
|
||||
func (p *AccountPages) SetPersonalOff(off bool) { p.personalOff = off }
|
||||
|
||||
// fillPlaces adds where the person can make keys, where their keys are, and
|
||||
// what applies in each place, resolved the way a request is: the whole chain
|
||||
// above a project, per-member limits, and the person's own.
|
||||
func (p *AccountPages) fillPlaces(ctx context.Context, user store.User, d *profileData) {
|
||||
d.Where = map[string]string{}
|
||||
projects, err := p.keys.ProjectsFor(ctx, user.ID)
|
||||
if err != nil {
|
||||
return nil
|
||||
p.log.Warn("could not list a person's projects", "err", err)
|
||||
}
|
||||
for _, pp := range projects {
|
||||
d.Contexts = append(d.Contexts, ChatContext{Value: pp.ID, Label: pp.Path})
|
||||
d.Where[pp.ID] = pp.Path
|
||||
}
|
||||
if !p.personalOff {
|
||||
d.Contexts = append(d.Contexts, ChatContext{Value: personalValue, Label: "Personal"})
|
||||
}
|
||||
if d.Memberships, err = p.keys.MembershipsOf(ctx, user.ID); err != nil {
|
||||
p.log.Warn("could not list a person's memberships", "err", err)
|
||||
}
|
||||
for _, c := range d.Contexts {
|
||||
project := c.Value
|
||||
if project == personalValue {
|
||||
project = ""
|
||||
}
|
||||
e, err := p.keys.ResolveFor(ctx, "session:"+user.ID, user.ID, project)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
d.LimitsBy = append(d.LimitsBy, contextLimits{Label: c.Label, Rows: limitRows(e)})
|
||||
}
|
||||
}
|
||||
|
||||
func limitRows(e store.Effective) []limitRow {
|
||||
var out []limitRow
|
||||
if l.RPM != nil {
|
||||
out = append(out, limitRow{"Requests per minute", itoa(*l.RPM)})
|
||||
if e.RPM != nil {
|
||||
out = append(out, limitRow{"Requests per minute", itoa(*e.RPM)})
|
||||
}
|
||||
if l.TPM != nil {
|
||||
out = append(out, limitRow{"Tokens per minute", itoa(*l.TPM)})
|
||||
if e.TPM != nil {
|
||||
out = append(out, limitRow{"Tokens per minute", itoa(*e.TPM)})
|
||||
}
|
||||
if l.Budget != nil {
|
||||
out = append(out, limitRow{"Budget", units(*l.Budget) + " per " + string(l.BudgetPeriod)})
|
||||
if e.Budget != nil {
|
||||
out = append(out, limitRow{"Budget", units(*e.Budget) + " per " + string(e.BudgetPeriod)})
|
||||
}
|
||||
if l.AllowedModels != nil {
|
||||
if len(l.AllowedModels) == 0 {
|
||||
if e.AllowedModels != nil {
|
||||
if len(e.AllowedModels) == 0 {
|
||||
out = append(out, limitRow{"Models", "none"})
|
||||
} else {
|
||||
out = append(out, limitRow{"Models", strings.Join(l.AllowedModels, ", ")})
|
||||
out = append(out, limitRow{"Models", strings.Join(e.AllowedModels, ", ")})
|
||||
}
|
||||
}
|
||||
return out
|
||||
@@ -534,6 +597,6 @@ func (p *AccountPages) renderWithCSRF(w http.ResponseWriter, r *http.Request,
|
||||
p.log.Error("could not list keys", "err", err)
|
||||
}
|
||||
d.Keys = keys
|
||||
d.Limits = p.limitsFor(r.Context(), user)
|
||||
p.fillPlaces(r.Context(), user, &d)
|
||||
render(w, "profile", d)
|
||||
}
|
||||
@@ -30,6 +30,22 @@ type QuotaAdmin interface {
|
||||
// which put projects under the wrong team when two organizations shared a
|
||||
// name.
|
||||
Tree(ctx context.Context) ([]store.TreeOrg, error)
|
||||
// People have limits of their own, across every key they hold.
|
||||
Users(ctx context.Context, state store.UserState) ([]store.User, error)
|
||||
UsageByUser(ctx context.Context, since time.Time) ([]store.UserUsage, error)
|
||||
}
|
||||
|
||||
// personRow is one person's own limits: across all their keys and projects.
|
||||
type personRow struct {
|
||||
ID, Email string
|
||||
RPM, TPM string
|
||||
Budget, Period string
|
||||
Models string
|
||||
HasAny bool
|
||||
Spend string
|
||||
Percent int
|
||||
HasPct bool
|
||||
Editing bool
|
||||
}
|
||||
|
||||
// quotaRow is one place a quota can be written, and what is written there.
|
||||
@@ -80,11 +96,27 @@ type quotaRow struct {
|
||||
// ModelsFrom names the nearest ancestor with a model list, for a row with
|
||||
// none of its own.
|
||||
ModelsFrom string
|
||||
|
||||
// Member is the per-member limit written here, summarised; MemberRaw holds
|
||||
// its fields for the form, and MemberEditing opens that form.
|
||||
Member string
|
||||
MemberRaw quotaFields
|
||||
MemberEditing bool
|
||||
}
|
||||
|
||||
// quotaFields is a limit as the form shows it.
|
||||
type quotaFields struct {
|
||||
RPM, TPM, Budget, Period, Models string
|
||||
HasAny bool
|
||||
}
|
||||
|
||||
type adminQuotasData struct {
|
||||
Nav Nav
|
||||
Rows []quotaRow
|
||||
Nav Nav
|
||||
Rows []quotaRow
|
||||
People []personRow
|
||||
// Personal summarises the defaults a person's own use falls under when
|
||||
// nobody set a limit for them.
|
||||
Personal string
|
||||
// BudgetsBind is false when no model has a price, which makes every budget
|
||||
// on this page a number that cannot move. Shown, because a limit that binds
|
||||
// on nothing and reads as "0% used" is worse than no limit at all.
|
||||
@@ -147,9 +179,10 @@ func (p *AccountPages) applyQuota(r *http.Request, s QuotaAdmin, admin store.Use
|
||||
// one that was clicked rather than one somebody named again in a box.
|
||||
scope, id := store.Scope(r.FormValue("scope")), r.FormValue("id")
|
||||
switch scope {
|
||||
case store.ScopeOrg, store.ScopeTeam, store.ScopeProject:
|
||||
case store.ScopeOrg, store.ScopeTeam, store.ScopeProject, store.ScopeUser,
|
||||
store.ScopeOrgMember, store.ScopeTeamMember, store.ScopeProjectMember:
|
||||
default:
|
||||
return "", errors.New("a quota belongs to an organization, a team or a project")
|
||||
return "", errors.New("a quota belongs to an organization, team, project or person")
|
||||
}
|
||||
if id == "" {
|
||||
return "", errors.New("which one?")
|
||||
@@ -237,6 +270,16 @@ func (p *AccountPages) renderQuotas(w http.ResponseWriter, r *http.Request,
|
||||
d.Error = "could not read the organizations"
|
||||
}
|
||||
d.Rows = quotaRows(tree, limits, spend)
|
||||
for i := range d.Rows {
|
||||
ms := store.MemberScope(d.Rows[i].Scope)
|
||||
if l, ok := limits[store.LimitOwner{Scope: ms, ID: d.Rows[i].ID}.CounterKey()]; ok {
|
||||
d.Rows[i].MemberRaw = fieldsOf(l)
|
||||
d.Rows[i].Member = describeLimits(l)
|
||||
}
|
||||
d.Rows[i].MemberEditing = d.Editing == string(ms)+":"+d.Rows[i].ID
|
||||
}
|
||||
d.People = p.personRows(r.Context(), s, limits, time.Now().Add(-window), d.Editing)
|
||||
d.Personal = p.personalSummary()
|
||||
for i := range d.Rows {
|
||||
d.Rows[i].Editing = d.Editing ==
|
||||
string(d.Rows[i].Scope)+":"+d.Rows[i].ID
|
||||
@@ -431,3 +474,59 @@ func dashUnits(v *int64) string {
|
||||
}
|
||||
return units(*v)
|
||||
}
|
||||
|
||||
func fieldsOf(l store.Limits) quotaFields {
|
||||
return quotaFields{
|
||||
RPM: dash(l.RPM), TPM: dash(l.TPM), Budget: dashUnits(l.Budget),
|
||||
Period: string(l.BudgetPeriod), Models: strings.Join(l.AllowedModels, ", "),
|
||||
HasAny: l.RPM != nil || l.TPM != nil || l.Budget != nil || l.AllowedModels != nil,
|
||||
}
|
||||
}
|
||||
|
||||
// personRows lists every approved person with the limits written for them and
|
||||
// what they spent, wherever they spent it.
|
||||
func (p *AccountPages) personRows(ctx context.Context, s QuotaAdmin,
|
||||
limits map[string]store.Limits, since time.Time, editing string,
|
||||
) []personRow {
|
||||
users, err := s.Users(ctx, "")
|
||||
if err != nil {
|
||||
p.log.Warn("could not list people for the quota page", "err", err)
|
||||
return nil
|
||||
}
|
||||
spent := map[string]int64{}
|
||||
if usage, err := s.UsageByUser(ctx, since); err == nil {
|
||||
for _, u := range usage {
|
||||
spent[u.UserID] = u.CostMicros
|
||||
}
|
||||
}
|
||||
var out []personRow
|
||||
for _, u := range users {
|
||||
if u.State == store.UserPending {
|
||||
continue
|
||||
}
|
||||
l := limits[store.LimitOwner{Scope: store.ScopeUser, ID: u.ID}.CounterKey()]
|
||||
f := fieldsOf(l)
|
||||
row := personRow{ID: u.ID, Email: u.Email, RPM: f.RPM, TPM: f.TPM, Budget: f.Budget,
|
||||
Period: f.Period, Models: f.Models, HasAny: f.HasAny, Spend: units(spent[u.ID]),
|
||||
Editing: editing == "user:"+u.ID}
|
||||
if l.Budget != nil && *l.Budget > 0 {
|
||||
row.Percent, row.HasPct = int(spent[u.ID]*100 / *l.Budget), true
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// SetPersonalDefaults tells the quota page what a person's own use falls under
|
||||
// when nobody set a limit for them.
|
||||
func (p *AccountPages) SetPersonalDefaults(l *store.Limits) { p.personalDefaults = l }
|
||||
|
||||
func (p *AccountPages) personalSummary() string {
|
||||
if p.personalOff {
|
||||
return "Personal use is off: people use the gateway only through their projects."
|
||||
}
|
||||
if p.personalDefaults == nil {
|
||||
return "Personal use has no default limit: someone with no limit of their own is bounded only by the cluster-wide defaults."
|
||||
}
|
||||
return "With no limit of their own, a person's personal use is held to " + describeLimits(*p.personalDefaults) + "."
|
||||
}
|
||||
@@ -18,6 +18,7 @@ type fakeQuotas struct {
|
||||
teams []store.TeamPath
|
||||
projects []store.ProjectPath
|
||||
limits map[string]store.Limits
|
||||
users []store.User
|
||||
usage map[store.Scope][]store.ScopeUsage
|
||||
|
||||
put []store.Limits
|
||||
@@ -76,6 +77,14 @@ type pricedNo struct{}
|
||||
func (pricedNo) AnythingPriced() bool { return false }
|
||||
|
||||
// oneTeam is an org with a team and a project under it.
|
||||
func (f *fakeQuotas) Users(context.Context, store.UserState) ([]store.User, error) {
|
||||
return f.users, nil
|
||||
}
|
||||
|
||||
func (f *fakeQuotas) UsageByUser(context.Context, time.Time) ([]store.UserUsage, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// Tree derives the tree from the flat lists the fake is given.
|
||||
func (f *fakeQuotas) Tree(context.Context) ([]store.TreeOrg, error) {
|
||||
var out []store.TreeOrg
|
||||
@@ -391,3 +400,41 @@ func TestALargerLimitBelowSaysItIsCapped(t *testing.T) {
|
||||
}
|
||||
|
||||
func ptrInt(v int) *int { return &v }
|
||||
|
||||
func TestAPerMemberAndAPersonsLimitAreSavedWhereTheyBelong(t *testing.T) {
|
||||
q := oneTeam()
|
||||
q.users = []store.User{{ID: "usr-a", Email: "ayse@x", State: store.UserActive}}
|
||||
mux := quotasPage(t, q, true)
|
||||
|
||||
mirrorPost(t, mux, "/admin/quotas", url.Values{"csrf": {"tok"},
|
||||
"scope": {"project-member"}, "id": {"proj-1"}, "rpm": {"20"}})
|
||||
mirrorPost(t, mux, "/admin/quotas", url.Values{"csrf": {"tok"},
|
||||
"scope": {"user"}, "id": {"usr-a"}, "budget": {"50"}, "period": {"month"}})
|
||||
|
||||
if len(q.put) != 2 {
|
||||
t.Fatalf("saved %d limits, want 2", len(q.put))
|
||||
}
|
||||
if q.put[0].Scope != store.ScopeProjectMember || q.put[0].ScopeID != "proj-1" || *q.put[0].RPM != 20 {
|
||||
t.Errorf("per-member limit saved as %+v", q.put[0])
|
||||
}
|
||||
if q.put[1].Scope != store.ScopeUser || q.put[1].ScopeID != "usr-a" || *q.put[1].Budget != 50_000_000 {
|
||||
t.Errorf("person's limit saved as %+v", q.put[1])
|
||||
}
|
||||
}
|
||||
|
||||
func TestThePeopleSectionShowsEachPersonsOwnLimit(t *testing.T) {
|
||||
q := oneTeam()
|
||||
q.users = []store.User{{ID: "usr-a", Email: "ayse@x", State: store.UserActive}}
|
||||
q.limits[store.LimitOwner{Scope: store.ScopeUser, ID: "usr-a"}.CounterKey()] =
|
||||
store.Limits{Scope: store.ScopeUser, ScopeID: "usr-a", RPM: ptrInt(7)}
|
||||
q.limits[store.LimitOwner{Scope: store.ScopeProjectMember, ID: "proj-1"}.CounterKey()] =
|
||||
store.Limits{Scope: store.ScopeProjectMember, ScopeID: "proj-1", RPM: ptrInt(20)}
|
||||
body := strings.Join(strings.Fields(
|
||||
mirrorGet(t, quotasPage(t, q, true), "/admin/quotas").Body.String()), " ")
|
||||
if !strings.Contains(body, `ayse@x</span>`) || !strings.Contains(body, `<td class="num">7</td>`) {
|
||||
t.Error("the person and their limit are not on the page")
|
||||
}
|
||||
if !strings.Contains(body, "each member here: rpm 20") {
|
||||
t.Error("the project's per-member limit is not shown")
|
||||
}
|
||||
}
|
||||
@@ -23,6 +23,7 @@ type fakeAdmin struct {
|
||||
createdOrg [1]string
|
||||
createdTeam [2]string
|
||||
createdProject [2]string
|
||||
joined, left []string
|
||||
err error
|
||||
}
|
||||
|
||||
@@ -67,18 +68,26 @@ func (f *fakeAdmin) Tree(context.Context) ([]store.TreeOrg, error) {
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
func (f *fakeAdmin) RenameOrg(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) RenameTeam(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) RenameProject(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) MoveTeam(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) MoveProject(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) DeleteOrg(context.Context, string) error { return f.err }
|
||||
func (f *fakeAdmin) DeleteTeam(context.Context, string) error { return f.err }
|
||||
func (f *fakeAdmin) DeleteProject(context.Context, string) error { return f.err }
|
||||
func (f *fakeAdmin) MoveUser(context.Context, string, string) (int, error) { return 0, f.err }
|
||||
func (f *fakeAdmin) DeleteUser(context.Context, string, time.Time) error { return f.err }
|
||||
func (f *fakeAdmin) AllKeys(context.Context) ([]store.KeyRow, error) { return nil, nil }
|
||||
func (f *fakeAdmin) RevokeKey(context.Context, string, time.Time) error { return f.err }
|
||||
func (f *fakeAdmin) RenameOrg(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) RenameTeam(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) RenameProject(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) MoveTeam(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) MoveProject(context.Context, string, string) error { return f.err }
|
||||
func (f *fakeAdmin) DeleteOrg(context.Context, string) error { return f.err }
|
||||
func (f *fakeAdmin) DeleteTeam(context.Context, string) error { return f.err }
|
||||
func (f *fakeAdmin) DeleteProject(context.Context, string) error { return f.err }
|
||||
func (f *fakeAdmin) AddMembership(_ context.Context, user string, scope store.Scope, id, _, _ string, _ time.Time) error {
|
||||
f.joined = append(f.joined, user+"@"+string(scope)+":"+id)
|
||||
return f.err
|
||||
}
|
||||
func (f *fakeAdmin) RemoveMembership(_ context.Context, user string, scope store.Scope, id string, _ time.Time) (int, error) {
|
||||
f.left = append(f.left, user+"@"+string(scope)+":"+id)
|
||||
return 1, f.err
|
||||
}
|
||||
func (f *fakeAdmin) AllMemberships(context.Context) ([]store.Membership, error) { return nil, nil }
|
||||
func (f *fakeAdmin) DeleteUser(context.Context, string, time.Time) error { return f.err }
|
||||
func (f *fakeAdmin) AllKeys(context.Context) ([]store.KeyRow, error) { return nil, nil }
|
||||
func (f *fakeAdmin) RevokeKey(context.Context, string, time.Time) error { return f.err }
|
||||
|
||||
func tenancyPage(t *testing.T, s *fakeAdmin, admin bool) *http.ServeMux {
|
||||
t.Helper()
|
||||
|
||||
+120
-19
@@ -5,6 +5,7 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
@@ -41,7 +42,9 @@ type AccountAdmin interface {
|
||||
DeleteOrg(ctx context.Context, id string) error
|
||||
DeleteTeam(ctx context.Context, id string) error
|
||||
DeleteProject(ctx context.Context, id string) error
|
||||
MoveUser(ctx context.Context, userID, projectID string) (int, error)
|
||||
AddMembership(ctx context.Context, userID string, scope store.Scope, scopeID, role, by string, at time.Time) error
|
||||
RemoveMembership(ctx context.Context, userID string, scope store.Scope, scopeID string, at time.Time) (int, error)
|
||||
AllMemberships(ctx context.Context) ([]store.Membership, error)
|
||||
DeleteUser(ctx context.Context, userID string, at time.Time) error
|
||||
AllKeys(ctx context.Context) ([]store.KeyRow, error)
|
||||
RevokeKey(ctx context.Context, id string, at time.Time) error
|
||||
@@ -50,7 +53,17 @@ type AccountAdmin interface {
|
||||
// userRow is an account as the page shows it: with where it is, not an id.
|
||||
type userRow struct {
|
||||
store.User
|
||||
ProjectPath string
|
||||
// Memberships are where the person is, by path; none is a person who uses
|
||||
// the gateway on their own.
|
||||
Memberships []store.Membership
|
||||
// Role is their role in the scope a list of members is drawn for.
|
||||
Role string
|
||||
}
|
||||
|
||||
// scopeOption is somewhere a person can be put, for a chooser.
|
||||
type scopeOption struct {
|
||||
Value string // "project:proj-…"
|
||||
Label string // "Acme / ml / training"
|
||||
}
|
||||
|
||||
// keyRow is a key as the page shows it.
|
||||
@@ -64,8 +77,12 @@ type adminUsersData struct {
|
||||
Pending []store.User
|
||||
Accounts []userRow
|
||||
Tree []store.TreeOrg
|
||||
// People and Keys are keyed by project id.
|
||||
People map[string][]userRow
|
||||
// Members is each scope's own members, keyed "project:<id>" and likewise
|
||||
// for teams and organizations; Keys is keyed by project id.
|
||||
Members map[string][]userRow
|
||||
// Scopes is every place a person can be added, organizations and teams
|
||||
// included.
|
||||
Scopes []scopeOption
|
||||
Keys map[string][]keyRow
|
||||
Projects []store.ProjectPath
|
||||
Orgs []store.Org
|
||||
@@ -105,12 +122,12 @@ func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
|
||||
mux.HandleFunc("POST /admin/users/{id}/approve", p.adminAction(s,
|
||||
func(ctx context.Context, admin store.User, id string, r *http.Request) (string, error) {
|
||||
project := r.FormValue("project")
|
||||
if project == "" {
|
||||
return "", errors.New("choose a project for their keys")
|
||||
}
|
||||
if err := s.ApproveUser(ctx, id, project, admin.Email, time.Now()); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if project == "" {
|
||||
return "approved, on their own for now", nil
|
||||
}
|
||||
return "approved into " + projectPath(ctx, s, project), nil
|
||||
}))
|
||||
|
||||
@@ -140,17 +157,35 @@ func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
|
||||
return "reinstated", nil
|
||||
}))
|
||||
|
||||
mux.HandleFunc("POST /admin/users/{id}/move", p.adminAction(s,
|
||||
func(ctx context.Context, _ store.User, id string, r *http.Request) (string, error) {
|
||||
project := r.FormValue("project")
|
||||
if project == "" {
|
||||
return "", errors.New("choose the project they go to")
|
||||
mux.HandleFunc("POST /admin/users/{id}/join", p.adminAction(s,
|
||||
func(ctx context.Context, admin store.User, id string, r *http.Request) (string, error) {
|
||||
scope, scopeID, ok := strings.Cut(r.FormValue("scope"), ":")
|
||||
if !ok || scopeID == "" {
|
||||
return "", errors.New("choose where they go")
|
||||
}
|
||||
moved, err := s.MoveUser(ctx, id, project)
|
||||
if err := s.AddMembership(ctx, id, store.Scope(scope), scopeID, store.RoleMember,
|
||||
admin.Email, time.Now()); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return "added to " + scopeLabel(ctx, s, store.Scope(scope), scopeID), nil
|
||||
}))
|
||||
|
||||
mux.HandleFunc("POST /admin/users/{id}/leave", p.adminAction(s,
|
||||
func(ctx context.Context, _ store.User, id string, r *http.Request) (string, error) {
|
||||
scope, scopeID, ok := strings.Cut(r.FormValue("scope"), ":")
|
||||
if !ok {
|
||||
return "", errors.New("nothing to leave")
|
||||
}
|
||||
label := scopeLabel(ctx, s, store.Scope(scope), scopeID)
|
||||
revoked, err := s.RemoveMembership(ctx, id, store.Scope(scope), scopeID, time.Now())
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return fmt.Sprintf("moved to %s, with %s", projectPath(ctx, s, project), plural(moved, "key", "keys")), nil
|
||||
msg := "removed from " + label
|
||||
if revoked > 0 {
|
||||
msg += "; " + plural(revoked, "key", "keys") + " they made there revoked"
|
||||
}
|
||||
return msg, nil
|
||||
}))
|
||||
|
||||
mux.HandleFunc("POST /admin/users/{id}/delete", p.adminAction(s,
|
||||
@@ -264,6 +299,25 @@ func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
|
||||
return "removed", nil
|
||||
}))
|
||||
|
||||
// The same as joining, from the scope's side: a form on a project, team or
|
||||
// organization that names the person.
|
||||
mux.HandleFunc("POST /admin/tenancy/{kind}/{id}/add", p.tenancyAction(s,
|
||||
func(ctx context.Context, r *http.Request) (string, error) {
|
||||
user := r.FormValue("user")
|
||||
if user == "" {
|
||||
return "", errors.New("choose who to add")
|
||||
}
|
||||
scope, id := store.Scope(r.PathValue("kind")), r.PathValue("id")
|
||||
if err := s.AddMembership(ctx, user, scope, id, store.RoleMember, "", time.Now()); err != nil {
|
||||
return "", err
|
||||
}
|
||||
who := user
|
||||
if u, err := s.UserByID(ctx, user); err == nil {
|
||||
who = u.Email
|
||||
}
|
||||
return who + " added to " + scopeLabel(ctx, s, scope, id), nil
|
||||
}))
|
||||
|
||||
mux.HandleFunc("POST /admin/keys/{id}/revoke", p.tenancyAction(s,
|
||||
func(ctx context.Context, r *http.Request) (string, error) {
|
||||
if err := s.RevokeKey(ctx, r.PathValue("id"), time.Now()); err != nil {
|
||||
@@ -285,6 +339,31 @@ func projectPath(ctx context.Context, s AccountAdmin, id string) string {
|
||||
return id
|
||||
}
|
||||
|
||||
// scopeLabel names an org, team or project by its path.
|
||||
func scopeLabel(ctx context.Context, s AccountAdmin, scope store.Scope, id string) string {
|
||||
switch scope {
|
||||
case store.ScopeProject:
|
||||
return projectPath(ctx, s, id)
|
||||
case store.ScopeTeam:
|
||||
if teams, err := s.AllTeams(ctx); err == nil {
|
||||
for _, t := range teams {
|
||||
if t.ID == id {
|
||||
return t.OrgName + " / " + t.Name
|
||||
}
|
||||
}
|
||||
}
|
||||
case store.ScopeOrg:
|
||||
if orgs, err := s.AllOrgs(ctx); err == nil {
|
||||
for _, o := range orgs {
|
||||
if o.ID == id {
|
||||
return o.Name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
// plainError says what a store error means to the person who caused it.
|
||||
func plainError(err error) error {
|
||||
switch {
|
||||
@@ -393,7 +472,7 @@ func (p *AccountPages) renderUsers(w http.ResponseWriter, r *http.Request,
|
||||
HasMirror: p.hasMirror,
|
||||
HasQuotas: p.hasQuotas,
|
||||
Now: time.Now().UTC().Format(time.RFC3339),
|
||||
People: map[string][]userRow{},
|
||||
Members: map[string][]userRow{},
|
||||
Keys: map[string][]keyRow{},
|
||||
}
|
||||
var err error
|
||||
@@ -415,14 +494,26 @@ func (p *AccountPages) renderUsers(w http.ResponseWriter, r *http.Request,
|
||||
|
||||
all, err := s.Users(ctx, "")
|
||||
logErr("the accounts", err)
|
||||
memberships, err := s.AllMemberships(ctx)
|
||||
logErr("the memberships", err)
|
||||
byUser := map[string][]store.Membership{}
|
||||
for _, m := range memberships {
|
||||
byUser[m.UserID] = append(byUser[m.UserID], m)
|
||||
}
|
||||
users := map[string]store.User{}
|
||||
for _, u := range all {
|
||||
if u.State == store.UserPending && u.ProjectID == "" {
|
||||
users[u.ID] = u
|
||||
if u.State == store.UserPending {
|
||||
d.Pending = append(d.Pending, u)
|
||||
continue
|
||||
}
|
||||
row := userRow{User: u, ProjectPath: paths[u.ProjectID]}
|
||||
d.Accounts = append(d.Accounts, row)
|
||||
d.People[u.ProjectID] = append(d.People[u.ProjectID], row)
|
||||
d.Accounts = append(d.Accounts, userRow{User: u, Memberships: byUser[u.ID]})
|
||||
}
|
||||
for _, m := range memberships {
|
||||
if u, ok := users[m.UserID]; ok {
|
||||
k := string(m.Scope) + ":" + m.ScopeID
|
||||
d.Members[k] = append(d.Members[k], userRow{User: u, Memberships: byUser[u.ID], Role: m.Role})
|
||||
}
|
||||
}
|
||||
|
||||
keys, err := s.AllKeys(ctx)
|
||||
@@ -438,6 +529,16 @@ func (p *AccountPages) renderUsers(w http.ResponseWriter, r *http.Request,
|
||||
logErr("the organizations", err)
|
||||
d.Teams, err = s.AllTeams(ctx)
|
||||
logErr("the teams", err)
|
||||
for _, o := range d.Orgs {
|
||||
d.Scopes = append(d.Scopes, scopeOption{"org:" + o.ID, o.Name})
|
||||
}
|
||||
for _, t := range d.Teams {
|
||||
d.Scopes = append(d.Scopes, scopeOption{"team:" + t.ID, t.OrgName + " / " + t.Name})
|
||||
}
|
||||
for _, pp := range d.Projects {
|
||||
d.Scopes = append(d.Scopes, scopeOption{"project:" + pp.ID, pp.Path})
|
||||
}
|
||||
sort.Slice(d.Scopes, func(i, j int) bool { return d.Scopes[i].Label < d.Scopes[j].Label })
|
||||
render(w, "admin_users", d)
|
||||
}
|
||||
|
||||
|
||||
+18
-8
@@ -20,21 +20,31 @@ type ChatModel struct {
|
||||
OnDemand bool
|
||||
}
|
||||
|
||||
// ChatContext is one thing the chat page can spend against: a project, or the
|
||||
// person themselves.
|
||||
type ChatContext struct {
|
||||
Value string
|
||||
Label string
|
||||
}
|
||||
|
||||
type chatData struct {
|
||||
Nav Nav
|
||||
User store.User
|
||||
Models []ChatModel
|
||||
CSRF string
|
||||
Version string
|
||||
Now string
|
||||
Nav Nav
|
||||
Contexts []ChatContext
|
||||
Context string
|
||||
User store.User
|
||||
Models []ChatModel
|
||||
CSRF string
|
||||
Version string
|
||||
Now string
|
||||
}
|
||||
|
||||
// Chat renders the in-browser chat for one signed-in person.
|
||||
func Chat(user store.User, models []ChatModel, version string) http.HandlerFunc {
|
||||
func Chat(user store.User, models []ChatModel, contexts []ChatContext, current, version string) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
noStore(w)
|
||||
render(w, "chat", chatData{
|
||||
Nav: navFrom(r, "chat"),
|
||||
Nav: navFrom(r, "chat"),
|
||||
Contexts: contexts, Context: current,
|
||||
User: user, Models: models, CSRF: csrfFor(r),
|
||||
Version: version, Now: time.Now().UTC().Format(time.RFC3339),
|
||||
})
|
||||
|
||||
@@ -20,7 +20,7 @@ func chatPage(t *testing.T, names ...string) string {
|
||||
|
||||
func chatPageWith(t *testing.T, models []ChatModel) string {
|
||||
t.Helper()
|
||||
h := Chat(store.User{Email: "a@example.com", ProjectID: "proj"}, models, "v1")
|
||||
h := Chat(store.User{Email: "a@example.com"}, models, nil, "", "v1")
|
||||
r := httptest.NewRequest(http.MethodGet, "http://x/chat", nil)
|
||||
w := httptest.NewRecorder()
|
||||
h(w, r)
|
||||
|
||||
@@ -24,15 +24,6 @@ type Nav struct {
|
||||
Mirror, Quotas bool
|
||||
// CSRF signs the sign-out form.
|
||||
CSRF string
|
||||
// Project is where the signed-in person's keys live, as a path. Carried
|
||||
// here because every page that says whose session it is wants it, and the
|
||||
// id it replaces ("project proj-3kq7…") told nobody anything.
|
||||
Project string
|
||||
}
|
||||
|
||||
// projectPaths is the part of the store that can name a project.
|
||||
type projectPaths interface {
|
||||
AllProjects(ctx context.Context) ([]store.ProjectPath, error)
|
||||
}
|
||||
|
||||
type navKey struct{}
|
||||
@@ -45,16 +36,6 @@ func (p *AccountPages) navFor(r *http.Request, user store.User, current string)
|
||||
Mirror: p.hasMirror,
|
||||
Quotas: p.hasQuotas,
|
||||
CSRF: csrfFor(r),
|
||||
Project: user.ProjectID,
|
||||
}
|
||||
if pp, ok := p.keys.(projectPaths); ok && user.ProjectID != "" {
|
||||
if all, err := pp.AllProjects(r.Context()); err == nil {
|
||||
for _, x := range all {
|
||||
if x.ID == user.ProjectID {
|
||||
n.Project = x.Path
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
@@ -430,3 +430,17 @@ table.quota-tree tr.q-depth-0 .q-name { font-weight: 600; }
|
||||
details.explain { margin-top: 1.5rem; font-size: .88rem; color: var(--muted); }
|
||||
details.explain > summary { cursor: pointer; color: var(--accent); }
|
||||
details.explain p { max-width: 48rem; }
|
||||
|
||||
/* Memberships as removable chips. */
|
||||
.chip-m { display: inline-flex; align-items: center; gap: .2rem; font-size: .78rem;
|
||||
border: 1px solid var(--line); border-radius: 999px; padding: .05rem .15rem .05rem .55rem;
|
||||
margin: .1rem .25rem .1rem 0; background: var(--card); white-space: nowrap; }
|
||||
.chip-m form.inline { display: inline; }
|
||||
.chip-x { background: none; color: var(--muted); padding: 0 .35rem; font-weight: 400; line-height: 1.2; }
|
||||
.chip-x:hover { color: var(--bad); filter: none; }
|
||||
td.where { max-width: 26rem; }
|
||||
.scope-members { background: var(--card); border: 1px solid var(--line); border-radius: 6px;
|
||||
padding: .5rem .6rem; margin: .4rem 0; min-width: 24rem; }
|
||||
h3.limits-for { font-size: .92rem; margin: 1rem 0 .4rem; }
|
||||
table.narrow-table { max-width: 30rem; }
|
||||
.q-act a + a { margin-left: .8rem; }
|
||||
@@ -51,7 +51,7 @@ Tell whoever you asked for access that you have signed up.</p>
|
||||
</head><body><div class="wrap">
|
||||
<header>
|
||||
<h1>Your keys</h1>
|
||||
<p class="sub">{{.User.Email}}{{if ne .User.Name .User.Email}} ({{.User.Name}}){{end}} · {{or .Nav.Project "no project"}}</p>
|
||||
<p class="sub">{{.User.Email}}{{if ne .User.Name .User.Email}} ({{.User.Name}}){{end}}</p>
|
||||
{{template "nav" .Nav}}
|
||||
</header>
|
||||
|
||||
@@ -72,15 +72,25 @@ Tell whoever you asked for access that you have signed up.</p>
|
||||
<form method="post" action="/profile/keys" class="narrow">
|
||||
<input type="hidden" name="csrf" value="{{.CSRF}}">
|
||||
<label>What is it for?<input type="text" name="name" placeholder="laptop, ci, notebook" required></label>
|
||||
{{if .Contexts}}
|
||||
<label>Spends against
|
||||
<select name="context">
|
||||
{{range .Contexts}}<option value="{{.Value}}">{{.Label}}</option>{{end}}
|
||||
</select></label>
|
||||
<button type="submit">Create</button>
|
||||
{{else}}
|
||||
<p class="note">You are in no project yet, and personal keys are off here.
|
||||
Ask an administrator to add you to one.</p>
|
||||
{{end}}
|
||||
</form>
|
||||
|
||||
<h2>Keys</h2>
|
||||
{{if .Keys}}
|
||||
<table><tr><th>Name</th><th>Key</th><th>Created</th><th>Last used</th><th>State</th><th></th></tr>
|
||||
<table><tr><th>Name</th><th>Key</th><th>Spends against</th><th>Created</th><th>Last used</th><th>State</th><th></th></tr>
|
||||
{{range .Keys}}<tr>
|
||||
<td>{{.Name}}</td>
|
||||
<td><code>{{.Prefix}}</code></td>
|
||||
<td>{{if .ProjectID}}{{or (index $.Where .ProjectID) "a project you have left"}}{{else}}Personal{{end}}</td>
|
||||
<td>{{date .CreatedAt}}</td>
|
||||
<td>{{ago .LastUsedAt}}</td>
|
||||
<td class="state state-{{state .}}">{{state .}}</td>
|
||||
@@ -111,11 +121,21 @@ signed in on has been signed out.</p>{{end}}
|
||||
<p class="note">Changing it signs out every other browser, which is the point if
|
||||
you are changing it because something went wrong.</p>
|
||||
|
||||
<h2>Where you are</h2>
|
||||
{{if .Memberships}}
|
||||
<p>{{range $i, $m := .Memberships}}{{if $i}} · {{end}}{{$m.Path}} <span class="opt">{{$m.Scope}}</span>{{end}}</p>
|
||||
{{else}}<p class="empty">You are not a member of any organization, team or project.</p>{{end}}
|
||||
|
||||
<h2>Your limits</h2>
|
||||
{{if .Limits}}
|
||||
<table><tr><th>Limit</th><th class="num">Value</th></tr>
|
||||
{{range .Limits}}<tr><td>{{.Name}}</td><td class="num">{{.Value}}</td></tr>{{end}}</table>
|
||||
{{else}}<p class="empty">No limits are set for you.</p>{{end}}
|
||||
{{range .LimitsBy}}
|
||||
<h3 class="limits-for">{{.Label}}</h3>
|
||||
{{if .Rows}}
|
||||
<table class="compact narrow-table"><tr><th>Limit</th><th class="num">Value</th></tr>
|
||||
{{range .Rows}}<tr><td>{{.Name}}</td><td class="num">{{.Value}}</td></tr>{{end}}</table>
|
||||
{{else}}<p class="empty">No limits here.</p>{{end}}
|
||||
{{else}}<p class="empty">Nowhere to spend yet.</p>{{end}}
|
||||
<p class="note">Everything that applies, from the organization down to you: the
|
||||
strictest value wins.</p>
|
||||
|
||||
<footer><span>llmgw {{.Version}}</span><span>{{.Now}}</span></footer>
|
||||
</div></body></html>{{end}}
|
||||
@@ -43,6 +43,7 @@ budgets bind.</p>
|
||||
<span class="q-name">{{.Path}}</span> <span class="q-kind">{{.Scope}}</span>
|
||||
{{if .Models}}<div class="q-sub">only <code>{{.Models}}</code></div>
|
||||
{{else if .ModelsFrom}}<div class="q-sub">models limited by {{.ModelsFrom}}</div>{{end}}
|
||||
{{if .Member}}<div class="q-sub">each member here: {{.Member}}</div>{{end}}
|
||||
{{if .Shadowed}}
|
||||
{{/* A value that is written here and never reached. Resolution takes the
|
||||
most restrictive along the chain, so without saying so the page would
|
||||
@@ -61,8 +62,17 @@ budgets bind.</p>
|
||||
<td class="q-act">
|
||||
{{if .Editing}}<a href="/admin/quotas">close</a>
|
||||
{{else}}<a href="/admin/quotas?edit={{.Scope}}:{{.ID}}">{{if .HasAny}}change{{else}}set{{end}}</a>{{end}}
|
||||
{{if .MemberEditing}}<a href="/admin/quotas">close</a>
|
||||
{{else}}<a href="/admin/quotas?edit={{.Scope}}-member:{{.ID}}" title="A limit each member here has separately">per member</a>{{end}}
|
||||
</td>
|
||||
</tr>
|
||||
{{if .MemberEditing}}
|
||||
<tr class="editing"><td colspan="6">
|
||||
{{template "quota-form" (dict "Scope" (printf "%s-member" .Scope) "ID" .ID "F" .MemberRaw "CSRF" $.CSRF
|
||||
"Title" (printf "Each member of %s, separately" .Crumb)
|
||||
"Note" "Every member gets this much here, counted apart from the others — a fair share rather than one pool.")}}
|
||||
</td></tr>
|
||||
{{end}}
|
||||
|
||||
{{if .Editing}}
|
||||
<tr class="editing"><td colspan="6">
|
||||
@@ -105,6 +115,38 @@ up — hover it to see where. A value set here is in normal type.</p>
|
||||
<a href="/admin/users">people page</a> first.</p>
|
||||
{{end}}
|
||||
|
||||
<h2 id="people-limits">People</h2>
|
||||
<p class="note">A person's own limit covers everything they do, across all their
|
||||
keys, projects and the chat page. {{.Personal}}</p>
|
||||
{{if .People}}
|
||||
<table class="quota-tree people-limits">
|
||||
<tr><th>Person</th><th class="num">Requests/min</th><th class="num">Tokens/min</th>
|
||||
<th class="num">Budget</th><th>Spent</th><th></th></tr>
|
||||
{{range .People}}
|
||||
<tr{{if .Editing}} class="editing"{{end}}>
|
||||
<td class="q-where"><span class="q-name">{{.Email}}</span>
|
||||
{{if .Models}}<div class="q-sub">only <code>{{.Models}}</code></div>{{end}}</td>
|
||||
<td class="num">{{or .RPM "—"}}</td>
|
||||
<td class="num">{{or .TPM "—"}}</td>
|
||||
<td class="num">{{if .Budget}}{{.Budget}}{{if .Period}}<span class="q-per">/{{.Period}}</span>{{end}}{{else}}—{{end}}</td>
|
||||
<td class="q-spent"><span class="q-spend">{{.Spend}}</span>
|
||||
{{if .HasPct}}<span class="q-meter{{if ge .Percent 90}} hot{{end}}"><i style="width:{{pct .Percent 100}}%"></i></span>
|
||||
<span class="q-pct">{{.Percent}}%</span>{{end}}</td>
|
||||
<td class="q-act">{{if .Editing}}<a href="/admin/quotas">close</a>
|
||||
{{else}}<a href="/admin/quotas?edit=user:{{.ID}}">{{if .HasAny}}change{{else}}set{{end}}</a>{{end}}</td>
|
||||
</tr>
|
||||
{{if .Editing}}
|
||||
<tr class="editing"><td colspan="6">
|
||||
{{template "quota-form" (dict "Scope" "user" "ID" .ID "CSRF" $.CSRF
|
||||
"F" (dict "RPM" .RPM "TPM" .TPM "Budget" .Budget "Period" .Period "Models" .Models "HasAny" .HasAny)
|
||||
"Title" (printf "%s, everywhere" .Email)
|
||||
"Note" "Across every key this person holds, every project they use and the chat page.")}}
|
||||
</td></tr>
|
||||
{{end}}
|
||||
{{end}}
|
||||
</table>
|
||||
{{else}}<p class="empty">Nobody has been approved yet.</p>{{end}}
|
||||
|
||||
<details class="explain">
|
||||
<summary>How limits combine</summary>
|
||||
<p>Along a branch the most restrictive value wins, so a team cannot raise what
|
||||
@@ -122,4 +164,32 @@ up — hover it to see where. A value set here is in normal type.</p>
|
||||
|
||||
{{/* A limit as the table shows it: the row's own value, else the one it is
|
||||
held to from above, marked as inherited and saying from where. */}}
|
||||
{{/* The form for a limit that is not a branch's own: per member, or a person. */}}
|
||||
{{define "quota-form"}}
|
||||
<form method="post" action="/admin/quotas" class="q-form">
|
||||
<input type="hidden" name="csrf" value="{{.CSRF}}">
|
||||
<input type="hidden" name="scope" value="{{.Scope}}">
|
||||
<input type="hidden" name="id" value="{{.ID}}">
|
||||
<p class="q-form-title"><strong>{{.Title}}</strong>. {{.Note}} A blank field means no limit of that kind.</p>
|
||||
<div class="field-row">
|
||||
<label>Requests / minute <input type="text" name="rpm" value="{{.F.RPM}}" placeholder="none"></label>
|
||||
<label>Tokens / minute <input type="text" name="tpm" value="{{.F.TPM}}" placeholder="none"></label>
|
||||
<label>Budget <input type="text" name="budget" value="{{.F.Budget}}" placeholder="none"></label>
|
||||
<label class="q-period">per
|
||||
<select name="period">
|
||||
<option value="month"{{if eq .F.Period "month"}} selected{{end}}>month</option>
|
||||
<option value="day"{{if eq .F.Period "day"}} selected{{end}}>day</option>
|
||||
</select></label>
|
||||
</div>
|
||||
<label>Only these models <span class="opt">comma separated; blank allows all</span>
|
||||
<input type="text" name="models" value="{{.F.Models}}" placeholder="every model"></label>
|
||||
<div class="q-form-actions">
|
||||
<button type="submit">Save</button>
|
||||
<a href="/admin/quotas">Cancel</a>
|
||||
<button type="submit" name="clear" value="1" class="link danger"
|
||||
{{if not .F.HasAny}}disabled{{end}}>Remove these limits</button>
|
||||
</div>
|
||||
</form>
|
||||
{{end}}
|
||||
|
||||
{{define "quota-value"}}{{if .Own}}{{.Own}}{{else if .Up}}<span class="q-up" title="set on {{.From}}">{{.Up}} ↑</span>{{else}}<span class="q-none">—</span>{{end}}{{end}}
|
||||
@@ -22,19 +22,18 @@
|
||||
|
||||
{{if .Pending}}
|
||||
<h2>Waiting for approval</h2>
|
||||
<table><tr><th>Email</th><th>Name</th><th>Signed up</th><th>Put them in</th><th></th></tr>
|
||||
<table><tr><th>Email</th><th>Name</th><th>Signed up</th><th>Approve, and put them in</th><th></th></tr>
|
||||
{{range .Pending}}<tr>
|
||||
<td>{{.Email}}</td><td>{{.Name}}</td><td>{{ago .CreatedAt}}</td>
|
||||
<td>
|
||||
{{if $.Projects}}
|
||||
<form method="post" action="/admin/users/{{.ID}}/approve" class="inline">
|
||||
<input type="hidden" name="csrf" value="{{$.CSRF}}">
|
||||
<select name="project" aria-label="Project for {{.Email}}">
|
||||
<option value="">No project yet: on their own</option>
|
||||
{{range $.Projects}}<option value="{{.ID}}">{{.Path}}</option>{{end}}
|
||||
</select>
|
||||
<button type="submit">Approve</button>
|
||||
</form>
|
||||
{{else}}<span class="note">Create a project first, below.</span>{{end}}
|
||||
</td>
|
||||
<td>
|
||||
<form method="post" action="/admin/users/{{.ID}}/delete" class="inline"
|
||||
@@ -61,6 +60,7 @@ project in the team — an account can only be approved into a project.</p>
|
||||
<div class="node-head">
|
||||
<strong class="node-name">{{$org.Name}}</strong>
|
||||
<span class="node-meta">{{len $org.Teams}} team{{if ne (len $org.Teams) 1}}s{{end}}</span>
|
||||
{{template "scope-members" (dict "Kind" "org" "ID" $org.ID "Name" $org.Name "D" $)}}
|
||||
<details class="edit"><summary>rename</summary>
|
||||
<form method="post" action="/admin/tenancy/org/{{$org.ID}}/rename">
|
||||
<input type="hidden" name="csrf" value="{{$.CSRF}}">
|
||||
@@ -82,6 +82,7 @@ project in the team — an account can only be approved into a project.</p>
|
||||
<div class="node-head">
|
||||
<span class="node-name">{{$team.Name}}</span>
|
||||
<span class="node-meta">{{len $team.Projects}} project{{if ne (len $team.Projects) 1}}s{{end}}</span>
|
||||
{{template "scope-members" (dict "Kind" "team" "ID" $team.ID "Name" $team.Name "D" $)}}
|
||||
<details class="edit"><summary>rename</summary>
|
||||
<form method="post" action="/admin/tenancy/team/{{$team.ID}}/rename">
|
||||
<input type="hidden" name="csrf" value="{{$.CSRF}}">
|
||||
@@ -113,7 +114,7 @@ project in the team — an account can only be approved into a project.</p>
|
||||
<details class="project" id="p-{{$p.ID}}"{{if eq $.Open $p.ID}} open{{end}}>
|
||||
<summary>
|
||||
<span class="node-name">{{$p.Name}}</span>
|
||||
<span class="node-meta">{{$p.Users}} {{if eq $p.Users 1}}person{{else}}people{{end}}
|
||||
<span class="node-meta">{{$p.Users}} member{{if ne $p.Users 1}}s{{end}}
|
||||
· {{$p.ActiveKeys}} key{{if ne $p.ActiveKeys 1}}s{{end}}{{if gt $p.Keys $p.ActiveKeys}} ({{sub $p.Keys $p.ActiveKeys}} revoked){{end}}</span>
|
||||
</summary>
|
||||
<div class="project-body">
|
||||
@@ -147,11 +148,12 @@ project in the team — an account can only be approved into a project.</p>
|
||||
{{else}}<span class="note">Removable once it has no people and never had a key.</span>{{end}}
|
||||
</div>
|
||||
|
||||
{{with index $.People $p.ID}}
|
||||
<table class="compact"><tr><th>Person</th><th>State</th><th>Last sign-in</th><th>Move to</th><th></th></tr>
|
||||
{{range .}}{{template "user-row-actions" (dict "U" . "D" $ "Open" $p.ID)}}{{end}}
|
||||
{{with index $.Members (printf "project:%s" $p.ID)}}
|
||||
<table class="compact"><tr><th>Member</th><th>State</th><th>Last sign-in</th><th></th></tr>
|
||||
{{range .}}{{template "member-row" (dict "U" . "D" $ "Scope" (printf "project:%s" $p.ID) "Open" $p.ID)}}{{end}}
|
||||
</table>
|
||||
{{else}}<p class="empty">Nobody is in this project.</p>{{end}}
|
||||
{{else}}<p class="empty">No members of its own. Members of its team or organization can use it too.</p>{{end}}
|
||||
{{template "add-member" (dict "Kind" "project" "ID" $p.ID "D" $ "Open" $p.ID)}}
|
||||
|
||||
{{with index $.Keys $p.ID}}
|
||||
<table class="compact"><tr><th>Key</th><th>Owner</th><th>State</th><th>Last used</th><th></th></tr>
|
||||
@@ -200,9 +202,11 @@ project in the team — an account can only be approved into a project.</p>
|
||||
|
||||
<h2 id="accounts">All accounts</h2>
|
||||
{{if .Accounts}}
|
||||
<table id="account-list"><tr><th>Person</th><th>State</th><th>Project</th><th>Last sign-in</th><th>Move to</th><th></th></tr>
|
||||
{{range .Accounts}}{{template "user-row-actions" (dict "U" . "D" $ "Open" "" "Path" true)}}{{end}}
|
||||
<table id="account-list"><tr><th>Person</th><th>State</th><th>Member of</th><th>Last sign-in</th><th>Add to</th><th></th></tr>
|
||||
{{range .Accounts}}{{template "account-row" (dict "U" . "D" $)}}{{end}}
|
||||
</table>
|
||||
<p class="note">Someone who is a member of nothing uses the gateway on their own:
|
||||
personal keys and the chat page, within their personal limits.</p>
|
||||
{{else}}<p class="empty">No accounts yet.</p>{{end}}
|
||||
|
||||
<p class="note">Not here on purpose: making someone an admin, resetting a password
|
||||
@@ -247,23 +251,8 @@ access than it had, so they need a shell on the control plane —
|
||||
</script>
|
||||
</body></html>{{end}}
|
||||
|
||||
{{define "user-row-actions"}}{{$u := .U}}{{$d := .D}}
|
||||
<tr data-q="{{lower $u.Email}} {{lower $u.Name}} {{lower $u.ProjectPath}}">
|
||||
<td>{{$u.Email}}{{if $u.IsAdmin}} <span class="tag">admin</span>{{end}}</td>
|
||||
<td class="state state-{{$u.State}}">{{$u.State}}</td>
|
||||
{{if .Path}}<td>{{or $u.ProjectPath "—"}}</td>{{end}}
|
||||
<td>{{ago $u.LastLoginAt}}</td>
|
||||
<td>
|
||||
<form method="post" action="/admin/users/{{$u.ID}}/move" class="inline">
|
||||
<input type="hidden" name="csrf" value="{{$d.CSRF}}">
|
||||
<input type="hidden" name="open" value="{{.Open}}">
|
||||
<select name="project" aria-label="Project for {{$u.Email}}">
|
||||
{{range $d.Projects}}<option value="{{.ID}}"{{if eq .ID $u.ProjectID}} selected{{end}}>{{.Path}}</option>{{end}}
|
||||
</select>
|
||||
<button type="submit" class="small">Move</button>
|
||||
</form>
|
||||
</td>
|
||||
<td class="actions">
|
||||
{{/* The actions every account row carries: suspend or reinstate, remove. */}}
|
||||
{{define "state-actions"}}{{$u := .U}}{{$d := .D}}
|
||||
{{if ne $u.ID $d.AdminID}}
|
||||
{{if eq (printf "%s" $u.State) "active"}}
|
||||
<form method="post" action="/admin/users/{{$u.ID}}/suspend" class="inline">
|
||||
@@ -285,5 +274,77 @@ access than it had, so they need a shell on the control plane —
|
||||
<button type="submit" class="link danger">remove</button>
|
||||
</form>
|
||||
{{else}}<span class="note">you</span>{{end}}
|
||||
{{end}}
|
||||
|
||||
{{/* A person in the list of every account: where they are, and where else
|
||||
they could be. */}}
|
||||
{{define "account-row"}}{{$u := .U}}{{$d := .D}}
|
||||
<tr data-q="{{lower $u.Email}} {{lower $u.Name}}{{range $u.Memberships}} {{lower .Path}}{{end}}">
|
||||
<td>{{$u.Email}}{{if $u.IsAdmin}} <span class="tag">admin</span>{{end}}</td>
|
||||
<td class="state state-{{$u.State}}">{{$u.State}}</td>
|
||||
<td class="where">
|
||||
{{range $u.Memberships}}<span class="chip-m">{{.Path}}
|
||||
<form method="post" action="/admin/users/{{$u.ID}}/leave" class="inline"
|
||||
hx-confirm="Take {{$u.Email}} out of {{.Path}}? Keys they made there are revoked.">
|
||||
<input type="hidden" name="csrf" value="{{$d.CSRF}}">
|
||||
<input type="hidden" name="scope" value="{{.Scope}}:{{.ScopeID}}">
|
||||
<button type="submit" class="chip-x" aria-label="Take out of {{.Path}}" title="Take out of {{.Path}}">×</button>
|
||||
</form></span>
|
||||
{{else}}<span class="opt">on their own</span>{{end}}
|
||||
</td>
|
||||
<td>{{ago $u.LastLoginAt}}</td>
|
||||
<td>
|
||||
<form method="post" action="/admin/users/{{$u.ID}}/join" class="inline">
|
||||
<input type="hidden" name="csrf" value="{{$d.CSRF}}">
|
||||
<select name="scope" aria-label="Add {{$u.Email}} to" required>
|
||||
<option value="">choose…</option>
|
||||
{{range $d.Scopes}}<option value="{{.Value}}">{{.Label}}</option>{{end}}
|
||||
</select>
|
||||
<button type="submit" class="small">Add</button>
|
||||
</form>
|
||||
</td>
|
||||
<td class="actions">{{template "state-actions" (dict "U" $u "D" $d "Open" "")}}</td>
|
||||
</tr>{{end}}
|
||||
|
||||
{{/* A member in a scope's own list: taking them out of here is the action. */}}
|
||||
{{define "member-row"}}{{$u := .U}}{{$d := .D}}
|
||||
<tr>
|
||||
<td>{{$u.Email}}{{if $u.IsAdmin}} <span class="tag">admin</span>{{end}}
|
||||
{{if gt (len $u.Memberships) 1}}<span class="opt">also in {{sub (len $u.Memberships) 1}} more</span>{{end}}</td>
|
||||
<td class="state state-{{$u.State}}">{{$u.State}}</td>
|
||||
<td>{{ago $u.LastLoginAt}}</td>
|
||||
<td class="actions">
|
||||
<form method="post" action="/admin/users/{{$u.ID}}/leave" class="inline"
|
||||
hx-confirm="Take {{$u.Email}} out of here? Keys they made here are revoked.">
|
||||
<input type="hidden" name="csrf" value="{{$d.CSRF}}">
|
||||
<input type="hidden" name="scope" value="{{.Scope}}">
|
||||
<input type="hidden" name="open" value="{{.Open}}">
|
||||
<button type="submit" class="link danger">take out</button>
|
||||
</form>
|
||||
</td>
|
||||
</tr>{{end}}
|
||||
|
||||
{{/* Adding a person to a scope, from the scope. */}}
|
||||
{{define "add-member"}}{{$d := .D}}
|
||||
<form method="post" action="/admin/tenancy/{{.Kind}}/{{.ID}}/add" class="add">
|
||||
<input type="hidden" name="csrf" value="{{$d.CSRF}}">
|
||||
<input type="hidden" name="open" value="{{.Open}}">
|
||||
<select name="user" aria-label="Person to add" required>
|
||||
<option value="">choose a person…</option>
|
||||
{{range $d.Accounts}}<option value="{{.ID}}">{{.Email}}</option>{{end}}
|
||||
</select>
|
||||
<button type="submit">Add member</button>
|
||||
</form>{{end}}
|
||||
|
||||
{{/* An org's or team's own members, folded away until asked for. */}}
|
||||
{{define "scope-members"}}{{$d := .D}}{{$k := printf "%s:%s" .Kind .ID}}
|
||||
<details class="edit"><summary>{{len (index $d.Members $k)}} member{{if ne (len (index $d.Members $k)) 1}}s{{end}}</summary>
|
||||
<div class="scope-members">
|
||||
{{with index $d.Members $k}}
|
||||
<table class="compact">
|
||||
{{range .}}{{template "member-row" (dict "U" . "D" $d "Scope" $k "Open" "")}}{{end}}
|
||||
</table>
|
||||
{{else}}<p class="note">Nobody is a member of {{.Name}} itself; a member here could use every project in it.</p>{{end}}
|
||||
{{template "add-member" (dict "Kind" .Kind "ID" .ID "D" $d "Open" "")}}
|
||||
</div>
|
||||
</details>{{end}}
|
||||
@@ -9,10 +9,23 @@
|
||||
</head><body><div class="wrap">
|
||||
<header>
|
||||
<h1>Chat</h1>
|
||||
<p class="sub">{{.User.Email}} · {{or .Nav.Project "no project"}}</p>
|
||||
<p class="sub">{{.User.Email}}</p>
|
||||
{{template "nav" .Nav}}
|
||||
</header>
|
||||
|
||||
{{if gt (len .Contexts) 1}}
|
||||
{{/* What this conversation spends against. A plain GET, so the model list
|
||||
below is the one this choice allows; the server checks it again on every
|
||||
message rather than trusting the page. */}}
|
||||
<form method="get" action="/chat" class="chat-context">
|
||||
<label class="inline-label">Using
|
||||
<select id="context" name="context" onchange="this.form.submit()">
|
||||
{{range .Contexts}}<option value="{{.Value}}"{{if eq .Value $.Context}} selected{{end}}>{{.Label}}</option>{{end}}
|
||||
</select></label>
|
||||
<noscript><button type="submit" class="link">switch</button></noscript>
|
||||
</form>
|
||||
{{else if .Contexts}}{{with index .Contexts 0}}<input type="hidden" id="context" value="{{.Value}}">{{end}}{{end}}
|
||||
|
||||
{{if .Models}}
|
||||
<div class="chat-bar">
|
||||
<label class="inline-label">Model
|
||||
@@ -172,7 +185,8 @@ access to it.</p>
|
||||
const resp = await fetch("/chat/send", {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json", "X-CSRF-Token": csrf },
|
||||
body: JSON.stringify({ model: model.value, messages: messages }),
|
||||
body: JSON.stringify({ model: model.value, messages: messages,
|
||||
context: (document.getElementById("context") || {}).value || "" }),
|
||||
});
|
||||
if (!resp.ok) {
|
||||
out.textContent = "(" + resp.status + ") " + (await resp.text()).slice(0, 400);
|
||||
|
||||
Reference in new issue
Block a user