follow sql schema
This commit is contained in:
@@ -0,0 +1,124 @@
|
||||
package identity
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"mediarr/database"
|
||||
"mediarr/ident"
|
||||
)
|
||||
|
||||
func GroupNameForRole(role string) (string, error) {
|
||||
switch role {
|
||||
case RoleAdmin:
|
||||
return "admins", nil
|
||||
case RoleMember:
|
||||
return "members", nil
|
||||
default:
|
||||
return "", fmt.Errorf("%w: %q", ErrInvalidRole, role)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Service) AddMember(ctx context.Context, groupID, memberID ident.UUID, role string) error {
|
||||
if role == "" {
|
||||
role = RoleMember
|
||||
}
|
||||
if role != RoleAdmin && role != RoleMember {
|
||||
return fmt.Errorf("%w: %q", ErrInvalidRole, role)
|
||||
}
|
||||
|
||||
group, err := s.db.Queries.GetPrincipal(ctx, groupID)
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return ErrGroupNotFound
|
||||
}
|
||||
return err
|
||||
}
|
||||
if group.Kind != KindGroup {
|
||||
return fmt.Errorf("%w: %s", ErrInvalidGroup, group.Kind)
|
||||
}
|
||||
|
||||
member, err := s.db.Queries.GetPrincipal(ctx, memberID)
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return ErrInvalidMember
|
||||
}
|
||||
return err
|
||||
}
|
||||
if member.Kind != KindUser && member.Kind != KindGuest {
|
||||
return fmt.Errorf("%w: %s", ErrInvalidMember, member.Kind)
|
||||
}
|
||||
|
||||
_, err = s.db.WriteQueries.CreateMembership(ctx, database.CreateMembershipParams{
|
||||
GroupID: groupID,
|
||||
MemberID: memberID,
|
||||
Role: role,
|
||||
CreatedAt: time.Now().UnixMilli(),
|
||||
})
|
||||
if err != nil {
|
||||
if isUniqueViolation(err) {
|
||||
return fmt.Errorf("%w: %s dans %s", ErrAlreadyMember, member.Name, group.Name)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) RemoveMember(ctx context.Context, groupID, memberID ident.UUID) error {
|
||||
_, err := s.db.Queries.GetMembership(ctx, database.GetMembershipParams{
|
||||
GroupID: groupID,
|
||||
MemberID: memberID,
|
||||
})
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return ErrNotMember
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
return s.db.WriteQueries.DeleteMembership(ctx, database.DeleteMembershipParams{
|
||||
GroupID: groupID,
|
||||
MemberID: memberID,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Service) ListGroups(ctx context.Context, memberID ident.UUID) ([]Group, error) {
|
||||
rows, err := s.db.Queries.ListMemberGroupsWithRole(ctx, memberID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
groups := make([]Group, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
groups = append(groups, Group{
|
||||
ID: row.ID,
|
||||
Name: row.Name,
|
||||
Role: row.Role,
|
||||
})
|
||||
}
|
||||
|
||||
return groups, nil
|
||||
}
|
||||
|
||||
func (s *Service) ListGroupMembers(ctx context.Context, groupID ident.UUID) ([]Member, error) {
|
||||
rows, err := s.db.Queries.ListGroupMembersWithRole(ctx, groupID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
members := make([]Member, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
members = append(members, Member{
|
||||
ID: row.ID,
|
||||
Name: row.Name,
|
||||
Kind: row.Kind,
|
||||
Role: row.Role,
|
||||
})
|
||||
}
|
||||
|
||||
return members, nil
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package identity
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestAddAndRemoveMember(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
user := mustCreatePrincipal(t, service, KindUser, "alice")
|
||||
members := mustGroup(t, service, "members")
|
||||
admins := mustGroup(t, service, "admins")
|
||||
|
||||
if err := service.AddMember(ctx, members.ID, user.ID, RoleMember); err != nil {
|
||||
t.Fatalf("AddMember(members) : %v", err)
|
||||
}
|
||||
if err := service.AddMember(ctx, admins.ID, user.ID, RoleAdmin); err != nil {
|
||||
t.Fatalf("AddMember(admins) : %v", err)
|
||||
}
|
||||
|
||||
groups, err := service.ListGroups(ctx, user.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("ListGroups : %v", err)
|
||||
}
|
||||
if !hasGroup(groups, "members") || !hasGroup(groups, "admins") {
|
||||
t.Fatalf("groupes = %+v, attendu members et admins", groups)
|
||||
}
|
||||
|
||||
list, err := service.ListGroupMembers(ctx, admins.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("ListGroupMembers : %v", err)
|
||||
}
|
||||
if len(list) != 1 || list[0].ID != user.ID || list[0].Role != RoleAdmin {
|
||||
t.Fatalf("membres = %+v, attendu alice admin", list)
|
||||
}
|
||||
|
||||
if err := service.RemoveMember(ctx, admins.ID, user.ID); err != nil {
|
||||
t.Fatalf("RemoveMember : %v", err)
|
||||
}
|
||||
|
||||
if err := service.RemoveMember(ctx, admins.ID, user.ID); !errors.Is(err, ErrNotMember) {
|
||||
t.Fatalf("erreur = %v, attendu ErrNotMember", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddMemberRejectsDuplicate(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
user := mustCreatePrincipal(t, service, KindUser, "alice")
|
||||
members := mustGroup(t, service, "members")
|
||||
|
||||
if err := service.AddMember(ctx, members.ID, user.ID, RoleMember); err != nil {
|
||||
t.Fatalf("AddMember : %v", err)
|
||||
}
|
||||
|
||||
err := service.AddMember(ctx, members.ID, user.ID, RoleMember)
|
||||
if !errors.Is(err, ErrAlreadyMember) {
|
||||
t.Fatalf("erreur = %v, attendu ErrAlreadyMember", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddMemberRejectsInvalidMember(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
user := mustCreatePrincipal(t, service, KindUser, "alice")
|
||||
members := mustGroup(t, service, "members")
|
||||
|
||||
err := service.AddMember(ctx, members.ID, members.ID, RoleMember)
|
||||
if !errors.Is(err, ErrInvalidMember) {
|
||||
t.Fatalf("erreur = %v, attendu ErrInvalidMember", err)
|
||||
}
|
||||
|
||||
err = service.AddMember(ctx, user.ID, user.ID, RoleMember)
|
||||
if !errors.Is(err, ErrInvalidGroup) {
|
||||
t.Fatalf("erreur = %v, attendu ErrInvalidGroup", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGroupNameForRole(t *testing.T) {
|
||||
name, err := GroupNameForRole(RoleAdmin)
|
||||
if err != nil || name != "admins" {
|
||||
t.Fatalf("admin : name = %q, err = %v", name, err)
|
||||
}
|
||||
|
||||
name, err = GroupNameForRole(RoleMember)
|
||||
if err != nil || name != "members" {
|
||||
t.Fatalf("member : name = %q, err = %v", name, err)
|
||||
}
|
||||
|
||||
if _, err := GroupNameForRole("super-admin"); !errors.Is(err, ErrInvalidRole) {
|
||||
t.Fatalf("erreur = %v, attendu ErrInvalidRole", err)
|
||||
}
|
||||
}
|
||||
|
||||
func hasGroup(groups []Group, name string) bool {
|
||||
for _, group := range groups {
|
||||
if group.Name == name {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package identity
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"mediarr/database"
|
||||
)
|
||||
|
||||
func newTestService(t *testing.T) *Service {
|
||||
t.Helper()
|
||||
|
||||
t.Chdir(t.TempDir())
|
||||
|
||||
err, db := database.NewDatabase(database.NewDatabaseParams{})
|
||||
if err != nil {
|
||||
t.Fatalf("NewDatabase : %v", err)
|
||||
}
|
||||
|
||||
t.Cleanup(func() {
|
||||
if err := db.Close(); err != nil {
|
||||
t.Errorf("Close : %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
return NewService(*db)
|
||||
}
|
||||
|
||||
func mustCreatePrincipal(t *testing.T, service *Service, kind, name string) *Principal {
|
||||
t.Helper()
|
||||
|
||||
created, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
|
||||
Kind: kind,
|
||||
Name: name,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreatePrincipal(%q) : %v", name, err)
|
||||
}
|
||||
|
||||
return created
|
||||
}
|
||||
|
||||
func mustGroup(t *testing.T, service *Service, name string) database.Principal {
|
||||
t.Helper()
|
||||
|
||||
group, err := service.db.Queries.GetPrincipalByNameAndKind(context.Background(), database.GetPrincipalByNameAndKindParams{
|
||||
Kind: KindGroup,
|
||||
Name: name,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("groupe %q : %v", name, err)
|
||||
}
|
||||
|
||||
return group
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package identity
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"mediarr/ident"
|
||||
)
|
||||
|
||||
const (
|
||||
KindCluster = "cluster"
|
||||
KindUser = "user"
|
||||
KindGuest = "guest"
|
||||
KindGroup = "group"
|
||||
KindSystem = "system"
|
||||
)
|
||||
|
||||
const (
|
||||
RoleAdmin = "admin"
|
||||
RoleMember = "member"
|
||||
)
|
||||
|
||||
type Principal struct {
|
||||
ID ident.UUID
|
||||
Kind string
|
||||
Name string
|
||||
Status string
|
||||
CreatedAt int64
|
||||
Groups []Group
|
||||
}
|
||||
|
||||
type Group struct {
|
||||
ID ident.UUID
|
||||
Name string
|
||||
Role string
|
||||
}
|
||||
|
||||
type Member struct {
|
||||
ID ident.UUID
|
||||
Name string
|
||||
Kind string
|
||||
Role string
|
||||
}
|
||||
|
||||
var (
|
||||
ErrInvalidRole = errors.New("rôle invalide")
|
||||
ErrAlreadyMember = errors.New("membre déjà présent dans le groupe")
|
||||
ErrNotMember = errors.New("membre absent du groupe")
|
||||
ErrInvalidMember = errors.New("membre invalide : utilisateur ou invité attendu")
|
||||
ErrInvalidGroup = errors.New("groupe invalide")
|
||||
ErrGroupNotFound = errors.New("groupe introuvable")
|
||||
ErrNameTaken = errors.New("nom déjà utilisé")
|
||||
ErrInvalidKind = errors.New("type de principal invalide")
|
||||
ErrInvalidName = errors.New("nom invalide")
|
||||
ErrInvalidStatus = errors.New("statut de principal invalide")
|
||||
)
|
||||
@@ -0,0 +1,142 @@
|
||||
package identity
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"mediarr/database"
|
||||
"mediarr/ident"
|
||||
)
|
||||
|
||||
const maxNameLen = 255
|
||||
|
||||
type CreatePrincipalParams struct {
|
||||
Kind string
|
||||
Name string
|
||||
PublicKey []byte
|
||||
Status string
|
||||
}
|
||||
|
||||
func (s *Service) CreatePrincipal(ctx context.Context, params CreatePrincipalParams) (*Principal, error) {
|
||||
if !validKind(params.Kind) {
|
||||
return nil, fmt.Errorf("%w: %q", ErrInvalidKind, params.Kind)
|
||||
}
|
||||
|
||||
name := strings.TrimSpace(params.Name)
|
||||
if name == "" || len(name) > maxNameLen {
|
||||
return nil, fmt.Errorf("%w: %q", ErrInvalidName, params.Name)
|
||||
}
|
||||
|
||||
status := params.Status
|
||||
if status == "" {
|
||||
status = "active"
|
||||
}
|
||||
if status != "active" && status != "disabled" && status != "revoked" {
|
||||
return nil, fmt.Errorf("%w: %q", ErrInvalidStatus, status)
|
||||
}
|
||||
|
||||
if params.Kind == KindCluster && len(params.PublicKey) == 0 {
|
||||
return nil, fmt.Errorf("%w: clé publique requise pour un cluster", ErrInvalidKind)
|
||||
}
|
||||
|
||||
id, err := ident.NewV7()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
_, err = s.db.WriteQueries.CreatePrincipal(ctx, database.CreatePrincipalParams{
|
||||
ID: id,
|
||||
Kind: params.Kind,
|
||||
Name: name,
|
||||
PublicKey: params.PublicKey,
|
||||
Status: status,
|
||||
CreatedAt: time.Now().UnixMilli(),
|
||||
})
|
||||
if err != nil {
|
||||
if isUniqueViolation(err) {
|
||||
return nil, fmt.Errorf("%w: %s", ErrNameTaken, name)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return s.GetPrincipal(ctx, id)
|
||||
}
|
||||
|
||||
func (s *Service) CreateGuest(ctx context.Context, name string) (*Principal, error) {
|
||||
group, err := s.groupByName(ctx, "guests")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
name = strings.TrimSpace(name)
|
||||
if name == "" || len(name) > maxNameLen {
|
||||
return nil, fmt.Errorf("%w: %q", ErrInvalidName, name)
|
||||
}
|
||||
|
||||
id, err := ident.NewV7()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
now := time.Now().UnixMilli()
|
||||
|
||||
err = s.withTx(ctx, func(q *database.Queries) error {
|
||||
if _, err := q.CreatePrincipal(ctx, database.CreatePrincipalParams{
|
||||
ID: id,
|
||||
Kind: KindGuest,
|
||||
Name: name,
|
||||
Status: "active",
|
||||
CreatedAt: now,
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
_, err := q.CreateMembership(ctx, database.CreateMembershipParams{
|
||||
GroupID: group.ID,
|
||||
MemberID: id,
|
||||
Role: RoleMember,
|
||||
CreatedAt: now,
|
||||
})
|
||||
return err
|
||||
})
|
||||
if err != nil {
|
||||
if isUniqueViolation(err) {
|
||||
return nil, fmt.Errorf("%w: %s", ErrNameTaken, name)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return s.GetPrincipal(ctx, id)
|
||||
}
|
||||
|
||||
func (s *Service) GetPrincipal(ctx context.Context, id ident.UUID) (*Principal, error) {
|
||||
principal, err := s.db.Queries.GetPrincipal(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
groups, err := s.ListGroups(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &Principal{
|
||||
ID: principal.ID,
|
||||
Kind: principal.Kind,
|
||||
Name: principal.Name,
|
||||
Status: principal.Status,
|
||||
CreatedAt: principal.CreatedAt,
|
||||
Groups: groups,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func validKind(kind string) bool {
|
||||
switch kind {
|
||||
case KindCluster, KindUser, KindGuest, KindGroup, KindSystem:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package identity
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCreatePrincipal(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
created, err := service.CreatePrincipal(ctx, CreatePrincipalParams{
|
||||
Kind: KindUser,
|
||||
Name: "alice",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreatePrincipal : %v", err)
|
||||
}
|
||||
|
||||
if created.ID.IsZero() {
|
||||
t.Fatal("identifiant vide")
|
||||
}
|
||||
if created.Kind != KindUser {
|
||||
t.Fatalf("kind = %q, attendu %q", created.Kind, KindUser)
|
||||
}
|
||||
if created.Name != "alice" {
|
||||
t.Fatalf("name = %q, attendu alice", created.Name)
|
||||
}
|
||||
if created.Status != "active" {
|
||||
t.Fatalf("status = %q, attendu active", created.Status)
|
||||
}
|
||||
if len(created.Groups) != 0 {
|
||||
t.Fatalf("groupes = %+v, attendu aucun", created.Groups)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreatePrincipalRejectsDuplicateName(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
mustCreatePrincipal(t, service, KindUser, "alice")
|
||||
|
||||
_, err := service.CreatePrincipal(ctx, CreatePrincipalParams{
|
||||
Kind: KindUser,
|
||||
Name: "alice",
|
||||
})
|
||||
if !errors.Is(err, ErrNameTaken) {
|
||||
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreatePrincipalRejectsInvalidKind(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
|
||||
_, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
|
||||
Kind: "robot",
|
||||
Name: "r2d2",
|
||||
})
|
||||
if !errors.Is(err, ErrInvalidKind) {
|
||||
t.Fatalf("erreur = %v, attendu ErrInvalidKind", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreatePrincipalRejectsInvalidName(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
|
||||
_, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
|
||||
Kind: KindUser,
|
||||
Name: " ",
|
||||
})
|
||||
if !errors.Is(err, ErrInvalidName) {
|
||||
t.Fatalf("erreur = %v, attendu ErrInvalidName", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateGuest(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
|
||||
guest, err := service.CreateGuest(context.Background(), "jean")
|
||||
if err != nil {
|
||||
t.Fatalf("CreateGuest : %v", err)
|
||||
}
|
||||
|
||||
if guest.Kind != KindGuest {
|
||||
t.Fatalf("kind = %q, attendu %q", guest.Kind, KindGuest)
|
||||
}
|
||||
if guest.Name != "jean" {
|
||||
t.Fatalf("name = %q, attendu jean", guest.Name)
|
||||
}
|
||||
if len(guest.Groups) != 1 || guest.Groups[0].Name != "guests" {
|
||||
t.Fatalf("groupes = %+v, attendu guests", guest.Groups)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateGuestRejectsDuplicateName(t *testing.T) {
|
||||
service := newTestService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
if _, err := service.CreateGuest(ctx, "jean"); err != nil {
|
||||
t.Fatalf("CreateGuest : %v", err)
|
||||
}
|
||||
|
||||
if _, err := service.CreateGuest(ctx, "jean"); !errors.Is(err, ErrNameTaken) {
|
||||
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
package identity
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"mediarr/database"
|
||||
)
|
||||
|
||||
type Service struct {
|
||||
db database.DatabaseClient
|
||||
}
|
||||
|
||||
func NewService(db database.DatabaseClient) *Service {
|
||||
return &Service{db: db}
|
||||
}
|
||||
|
||||
func (s *Service) withTx(ctx context.Context, fn func(*database.Queries) error) error {
|
||||
tx, err := s.db.WriteDB.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() {
|
||||
_ = tx.Rollback()
|
||||
}()
|
||||
|
||||
if err := fn(s.db.WriteQueries.WithTx(tx)); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return tx.Commit()
|
||||
}
|
||||
|
||||
func isUniqueViolation(err error) bool {
|
||||
return err != nil && strings.Contains(strings.ToLower(err.Error()), "unique constraint failed")
|
||||
}
|
||||
|
||||
func (s *Service) groupByName(ctx context.Context, name string) (database.Principal, error) {
|
||||
group, err := s.db.Queries.GetPrincipalByNameAndKind(ctx, database.GetPrincipalByNameAndKindParams{
|
||||
Kind: KindGroup,
|
||||
Name: name,
|
||||
})
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return database.Principal{}, fmt.Errorf("%w: %s", ErrGroupNotFound, name)
|
||||
}
|
||||
return database.Principal{}, err
|
||||
}
|
||||
|
||||
return group, nil
|
||||
}
|
||||
Reference in New Issue
Block a user