mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
5f3969a830
Let people use any Unicode emoji through a searchable, virtualized picker. Keep reaction counts accurate and requests optimistic and idempotent. Refresh demo content so signed-in visitors can participate. BREAKING CHANGE: Remove the MEMO_RELATED instance setting and memoRelatedSetting configuration value. Remove their declarations and lifecycle references from configuration files; existing reactions are preserved.
740 lines
27 KiB
Go
740 lines
27 KiB
Go
package configuration
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/pkg/errors"
|
|
"google.golang.org/protobuf/proto"
|
|
|
|
"github.com/usememos/memos/core/identityprovider"
|
|
"github.com/usememos/memos/core/instancesetting"
|
|
coreuser "github.com/usememos/memos/core/user"
|
|
apipb "github.com/usememos/memos/proto/gen/api"
|
|
storepb "github.com/usememos/memos/proto/gen/store"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
// Reader is what a plan reads from the instance. *store.Store implements it.
|
|
// Every read bypasses caches, so a plan sees what is stored.
|
|
type Reader interface {
|
|
GetConfigurationState(ctx context.Context) (*storepb.InstanceConfigurationState, error)
|
|
ListIdentityProviders(ctx context.Context, find *store.FindIdentityProvider) ([]*storepb.IdentityProvider, error)
|
|
GetUncachedInstanceSetting(ctx context.Context, find *store.FindInstanceSetting) (*storepb.InstanceSetting, error)
|
|
ListUsers(ctx context.Context, find *store.FindUser) ([]*store.User, error)
|
|
ListUserIdentities(ctx context.Context, find *store.FindUserIdentity) ([]*store.UserIdentity, error)
|
|
}
|
|
|
|
// Plan is what apply would change.
|
|
type Plan struct {
|
|
// Message is the plan as printed and as --json returns it.
|
|
Message *apipb.Plan
|
|
// next is the state record apply writes; nil when the plan has errors.
|
|
next *storepb.InstanceConfigurationState
|
|
// operations are the writes apply makes, in apply order.
|
|
operations []*operation
|
|
}
|
|
|
|
// operation is what apply writes for one resource change.
|
|
type operation struct {
|
|
change *apipb.ResourceChange
|
|
kind Kind
|
|
|
|
// The identity provider to write, and the stored one's ID when it exists.
|
|
provider *storepb.IdentityProvider
|
|
providerID int32
|
|
|
|
// The instance setting to write, or the key to reset.
|
|
setting *storepb.InstanceSetting
|
|
settingKey storepb.InstanceSettingKey
|
|
|
|
// The managed part of a declared user, and the stored user when it exists.
|
|
// A user created without a declared password gets an unusable random one.
|
|
user *apipb.User
|
|
actualUser *store.User
|
|
randomPassword bool
|
|
|
|
// The identity link to write, without its user ID, which apply resolves
|
|
// from identityUsername once the user exists; and the stored link, if any.
|
|
identity *store.UserIdentity
|
|
identityUsername string
|
|
actualIdentity *store.UserIdentity
|
|
}
|
|
|
|
// Valid reports whether the plan can be applied.
|
|
func (p *Plan) Valid() bool {
|
|
return len(p.Message.Errors) == 0
|
|
}
|
|
|
|
// HasChanges reports whether apply would write anything.
|
|
func (p *Plan) HasChanges() bool {
|
|
return p.Message.StateRecordChanges
|
|
}
|
|
|
|
// Apply order: identity providers are created and updated first, so a GENERAL
|
|
// setting that needs one finds it; linked identities follow the users they
|
|
// belong to; users are destroyed before providers.
|
|
const (
|
|
rankIdentityProvider = iota
|
|
rankInstanceSetting
|
|
rankUser
|
|
rankLinkedIdentity
|
|
rankLinkedIdentityDestroy
|
|
rankUserDestroy
|
|
rankIdentityProviderDestroy
|
|
)
|
|
|
|
type rankedChange struct {
|
|
rank int
|
|
change *apipb.ResourceChange
|
|
op *operation
|
|
}
|
|
|
|
// ComputePlan compares the desired state with what reader holds and returns
|
|
// what apply would do. It never writes. Problems that stop an apply, such as
|
|
// a managed resource no file declares any longer, are in the plan's errors.
|
|
func ComputePlan(ctx context.Context, desired *Desired, reader Reader) (*Plan, error) {
|
|
state, err := reader.GetConfigurationState(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p := &planner{
|
|
ctx: ctx,
|
|
desired: desired,
|
|
reader: reader,
|
|
state: state,
|
|
managed: map[string]*storepb.InstanceConfigurationState_ManagedResource{},
|
|
lifecycle: map[string]*apipb.Lifecycle{},
|
|
removed: map[string]*apipb.Removed{},
|
|
message: &apipb.Plan{Serial: state.Serial, Warnings: slices.Clone(desired.Warnings)},
|
|
}
|
|
for _, resource := range state.Resources {
|
|
p.managed[resource.Name] = resource
|
|
}
|
|
for _, lifecycle := range desired.Configuration.Lifecycle {
|
|
p.lifecycle[lifecycle.Resource] = lifecycle
|
|
}
|
|
for _, removed := range desired.Configuration.Removed {
|
|
p.removed[removed.Resource] = removed
|
|
}
|
|
|
|
steps := []func() error{p.planIdentityProviders, p.planInstanceSettings, p.planUsers, p.planLinkedIdentities, p.planUndeclared, p.checkAuthentication}
|
|
for _, step := range steps {
|
|
if err := step(); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return p.finish(), nil
|
|
}
|
|
|
|
type planner struct {
|
|
ctx context.Context
|
|
desired *Desired
|
|
reader Reader
|
|
state *storepb.InstanceConfigurationState
|
|
managed map[string]*storepb.InstanceConfigurationState_ManagedResource
|
|
lifecycle map[string]*apipb.Lifecycle
|
|
removed map[string]*apipb.Removed
|
|
message *apipb.Plan
|
|
changes []rankedChange
|
|
next []*storepb.InstanceConfigurationState_ManagedResource
|
|
|
|
providersByUID map[string]*storepb.IdentityProvider
|
|
// The stored users the configuration declares, by username.
|
|
declaredUsers map[string]*store.User
|
|
|
|
// What the authentication invariant needs about the planned end state.
|
|
providersAfter map[string]bool
|
|
providerDestroyed bool
|
|
generalAfter *storepb.InstanceGeneralSetting
|
|
generalPlanned bool
|
|
}
|
|
|
|
func (p *planner) fail(resource string, format string, args ...any) {
|
|
p.message.Errors = append(p.message.Errors, resource+": "+fmt.Sprintf(format, args...))
|
|
}
|
|
|
|
// declared records the action for a declared resource from its field changes
|
|
// and whether it exists, and the state record entry apply would write.
|
|
func (p *planner) declared(rank int, name string, kind Kind, exists bool, changes []*apipb.FieldChange, entry *storepb.InstanceConfigurationState_ManagedResource, op *operation) {
|
|
managed := p.managed[name]
|
|
change := &apipb.ResourceChange{Resource: name, Source: p.desired.Sources[name], FieldChanges: changes}
|
|
switch {
|
|
case !exists:
|
|
change.Action = apipb.ResourceChange_CREATE
|
|
if managed != nil {
|
|
change.Drift = true
|
|
change.Message = "deleted outside the configuration since the last apply"
|
|
}
|
|
case managed == nil:
|
|
change.Action = apipb.ResourceChange_ADOPT
|
|
case len(changes) > 0:
|
|
change.Action = apipb.ResourceChange_UPDATE
|
|
// The declaration is what was last applied, so the instance changed.
|
|
change.Drift = managed.Digest == entry.Digest
|
|
default:
|
|
change.Action = apipb.ResourceChange_NO_OP
|
|
}
|
|
|
|
lifecycle := p.lifecycle[name]
|
|
entry.Name = name
|
|
entry.Kind = string(kind)
|
|
entry.Source = p.desired.Sources[name]
|
|
entry.IgnoredFields = slices.Clone(lifecycle.GetIgnoreChanges())
|
|
entry.PreventDestroy = lifecycle.GetPreventDestroy()
|
|
if change.Action == apipb.ResourceChange_NO_OP && managed != nil {
|
|
entry.AppliedTs = managed.AppliedTs
|
|
}
|
|
op.change, op.kind = change, kind
|
|
p.changes = append(p.changes, rankedChange{rank: rank, change: change, op: op})
|
|
p.next = append(p.next, entry)
|
|
}
|
|
|
|
func (p *planner) planIdentityProviders() error {
|
|
providers, err := p.reader.ListIdentityProviders(p.ctx, &store.FindIdentityProvider{})
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to read identity providers")
|
|
}
|
|
p.providersByUID = map[string]*storepb.IdentityProvider{}
|
|
p.providersAfter = map[string]bool{}
|
|
for _, provider := range providers {
|
|
p.providersByUID[provider.Uid] = provider
|
|
p.providersAfter[provider.Uid] = true
|
|
}
|
|
|
|
for _, declared := range sortedByName(p.desired.Configuration.IdentityProviders, (*apipb.IdentityProvider).GetName) {
|
|
desiredStore := identityprovider.ToStore(declared)
|
|
desiredAPI := identityprovider.FromStore(desiredStore)
|
|
var actualAPI proto.Message
|
|
ignored := p.lifecycle[declared.Name].GetIgnoreChanges()
|
|
op := &operation{provider: desiredStore}
|
|
actual, exists := p.providersByUID[desiredStore.Uid]
|
|
if exists {
|
|
actualAPI = identityprovider.FromStore(actual)
|
|
op.providerID = actual.Id
|
|
if len(ignored) > 0 {
|
|
merged := proto.CloneOf(desiredAPI)
|
|
copyFields(merged, actualAPI, ignored)
|
|
op.provider = identityprovider.ToStore(merged)
|
|
}
|
|
}
|
|
changes := diffResource(actualAPI, desiredAPI, ignored)
|
|
entry := &storepb.InstanceConfigurationState_ManagedResource{
|
|
ManagedFields: []string{"*"},
|
|
Digest: digest(desiredAPI, p.lifecycle[declared.Name]),
|
|
}
|
|
p.declared(rankIdentityProvider, declared.Name, KindIdentityProvider, exists, changes, entry, op)
|
|
p.providersAfter[desiredStore.Uid] = true
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *planner) planInstanceSettings() error {
|
|
for _, declared := range sortedByName(p.desired.Configuration.InstanceSettings, (*apipb.InstanceSetting).GetName) {
|
|
desiredStore, err := p.settingToStore(declared)
|
|
if err != nil {
|
|
p.fail(declared.Name, "%v", err)
|
|
continue
|
|
}
|
|
actual, err := p.reader.GetUncachedInstanceSetting(p.ctx, &store.FindInstanceSetting{Name: desiredStore.Key.String()})
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to read %s", declared.Name)
|
|
}
|
|
desiredAPI, err := p.settingFromStore(desiredStore)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var actualAPI proto.Message
|
|
ignored := p.lifecycle[declared.Name].GetIgnoreChanges()
|
|
op := &operation{setting: desiredStore, settingKey: desiredStore.Key}
|
|
if actual != nil {
|
|
instancesetting.Normalize(actual)
|
|
if actualAPI, err = p.settingFromStore(actual); err != nil {
|
|
return err
|
|
}
|
|
if len(ignored) > 0 {
|
|
merged := proto.CloneOf(desiredAPI)
|
|
copyFields(merged, actualAPI, ignored)
|
|
if op.setting, err = p.settingToStore(merged); err != nil {
|
|
p.fail(declared.Name, "%v", err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
changes := diffResource(actualAPI, desiredAPI, ignored)
|
|
entry := &storepb.InstanceConfigurationState_ManagedResource{
|
|
ManagedFields: []string{"*"},
|
|
Digest: digest(desiredAPI, p.lifecycle[declared.Name]),
|
|
References: settingReferences(declared),
|
|
}
|
|
p.declared(rankInstanceSetting, declared.Name, KindInstanceSetting, actual != nil, changes, entry, op)
|
|
if desiredStore.Key == storepb.InstanceSettingKey_GENERAL {
|
|
p.generalAfter = desiredStore.GetGeneralSetting()
|
|
p.generalPlanned = true
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// settingToStore converts a declared setting as apply writes it: usage limits
|
|
// name users by resource name, resolved here, and the value is normalized the
|
|
// way every stored write normalizes it, so equal settings compare equal.
|
|
func (p *planner) settingToStore(setting *apipb.InstanceSetting) (*storepb.InstanceSetting, error) {
|
|
stored := instancesetting.ToStore(setting)
|
|
if stored.Key == storepb.InstanceSettingKey_USAGE_LIMITS {
|
|
names := []string{}
|
|
for _, limit := range setting.GetUsageLimitsSetting().GetLimits() {
|
|
names = append(names, limit.GetUsers()...)
|
|
}
|
|
userIDs, err := p.resolveUserNames(names)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
usageLimits, err := instancesetting.UsageLimitsToStore(setting.GetUsageLimitsSetting(), userIDs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stored.Value = &storepb.InstanceSetting_UsageLimitsSetting{UsageLimitsSetting: usageLimits}
|
|
}
|
|
instancesetting.Normalize(stored)
|
|
return stored, nil
|
|
}
|
|
|
|
// settingReferences lists the users a declared usage-limits setting names,
|
|
// sorted and without repeats; other settings name no resources.
|
|
func settingReferences(setting *apipb.InstanceSetting) []string {
|
|
var names []string
|
|
for _, limit := range setting.GetUsageLimitsSetting().GetLimits() {
|
|
names = append(names, limit.GetUsers()...)
|
|
}
|
|
slices.Sort(names)
|
|
return slices.Compact(names)
|
|
}
|
|
|
|
func (p *planner) settingFromStore(setting *storepb.InstanceSetting) (*apipb.InstanceSetting, error) {
|
|
result := instancesetting.FromStore(setting)
|
|
if setting.Key == storepb.InstanceSettingKey_USAGE_LIMITS {
|
|
userIDs := []int32{}
|
|
for _, limit := range setting.GetUsageLimitsSetting().GetLimits() {
|
|
userIDs = append(userIDs, limit.GetUserIds()...)
|
|
}
|
|
userNames := map[int32]string{}
|
|
if len(userIDs) > 0 {
|
|
users, err := p.reader.ListUsers(p.ctx, &store.FindUser{IDList: userIDs})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to read users named by usage limits")
|
|
}
|
|
for _, user := range users {
|
|
userNames[user.ID] = coreuser.NamePrefix + user.Username
|
|
}
|
|
}
|
|
result.Value = &apipb.InstanceSetting_UsageLimitsSetting_{
|
|
UsageLimitsSetting: instancesetting.UsageLimitsFromStore(setting.GetUsageLimitsSetting(), userNames),
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (p *planner) resolveUserNames(names []string) (map[string]int32, error) {
|
|
if len(names) == 0 {
|
|
return map[string]int32{}, nil
|
|
}
|
|
usernames := make([]string, 0, len(names))
|
|
for _, name := range names {
|
|
usernames = append(usernames, strings.TrimPrefix(name, coreuser.NamePrefix))
|
|
}
|
|
users, err := p.reader.ListUsers(p.ctx, &store.FindUser{UsernameList: usernames})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to read users named by usage limits")
|
|
}
|
|
byName := map[string]int32{}
|
|
for _, user := range users {
|
|
byName[coreuser.NamePrefix+user.Username] = user.ID
|
|
}
|
|
for _, name := range names {
|
|
if _, ok := byName[name]; !ok {
|
|
return nil, errors.Errorf("usageLimitsSetting names %s, which does not exist", name)
|
|
}
|
|
}
|
|
return byName, nil
|
|
}
|
|
|
|
func (p *planner) planUsers() error {
|
|
declaredUsers := sortedByName(p.desired.Configuration.Users, (*apipb.User).GetName)
|
|
usernames := make([]string, 0, len(declaredUsers))
|
|
for _, user := range declaredUsers {
|
|
usernames = append(usernames, user.Username)
|
|
}
|
|
actualByName := map[string]*store.User{}
|
|
if len(usernames) > 0 {
|
|
users, err := p.reader.ListUsers(p.ctx, &store.FindUser{UsernameList: usernames})
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to read users")
|
|
}
|
|
for _, user := range users {
|
|
actualByName[user.Username] = user
|
|
}
|
|
}
|
|
p.declaredUsers = actualByName
|
|
|
|
linkedUsers := map[string]bool{}
|
|
for _, identity := range p.desired.Configuration.LinkedIdentities {
|
|
userName, _ := splitLinkedIdentityName(identity.GetName())
|
|
linkedUsers[userName] = true
|
|
}
|
|
|
|
for _, declared := range declaredUsers {
|
|
name := declared.Name
|
|
actual := actualByName[declared.Username]
|
|
lifecycle := p.lifecycle[name]
|
|
optional := p.desired.UserFields[name]
|
|
version := lifecycle.GetWriteOnlyVersion()
|
|
recorded := p.managed[name].GetWriteOnlyVersion()
|
|
sendPassword := actual == nil || version > recorded
|
|
// A user with a declared linked identity signs in through its provider,
|
|
// so it may be created without a password, as SSO provisioning creates
|
|
// users: with a random password nobody knows.
|
|
randomPassword := actual == nil && declared.Password == "" && linkedUsers[name]
|
|
if randomPassword {
|
|
sendPassword = false
|
|
}
|
|
if sendPassword && declared.Password == "" {
|
|
if actual == nil {
|
|
p.fail(name, "password is required to create the user, unless a linked identity is declared for it")
|
|
} else {
|
|
p.fail(name, "writeOnlyVersion is %d, above the %d last applied, but no password is declared", version, recorded)
|
|
}
|
|
continue
|
|
}
|
|
|
|
managedView := managedUserView(declared, optional)
|
|
changes := p.userChanges(managedView, actual, sendPassword, version)
|
|
entry := &storepb.InstanceConfigurationState_ManagedResource{
|
|
ManagedFields: append([]string{"username", "role"}, optional...),
|
|
Digest: digest(managedView, lifecycle),
|
|
WriteOnlyVersion: max(version, recorded),
|
|
}
|
|
op := &operation{user: managedView, actualUser: actual, randomPassword: randomPassword}
|
|
p.declared(rankUser, name, KindUser, actual != nil, changes, entry, op)
|
|
if randomPassword {
|
|
op.change.Message = "created without a password; signs in through its linked identity"
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// managedUserView is the part of a declared user the configuration manages.
|
|
func managedUserView(declared *apipb.User, optional []string) *apipb.User {
|
|
view := &apipb.User{Name: declared.Name, Username: declared.Username, Role: declared.Role, Password: declared.Password}
|
|
if slices.Contains(optional, "displayName") {
|
|
view.DisplayName = declared.DisplayName
|
|
}
|
|
if slices.Contains(optional, "email") {
|
|
// Layer 2 already rejected an email that does not normalize.
|
|
view.Email, _ = store.NormalizeEmail(declared.Email)
|
|
}
|
|
return view
|
|
}
|
|
|
|
func (p *planner) userChanges(view *apipb.User, actual *store.User, sendPassword bool, version int32) []*apipb.FieldChange {
|
|
ignored := p.lifecycle[view.Name].GetIgnoreChanges()
|
|
optional := p.desired.UserFields[view.Name]
|
|
changes := []*apipb.FieldChange{}
|
|
add := func(path, before, after string) {
|
|
if slices.Contains(ignored, path) {
|
|
return
|
|
}
|
|
if before != after {
|
|
changes = append(changes, &apipb.FieldChange{Path: path, Before: before, After: after})
|
|
}
|
|
}
|
|
if actual == nil {
|
|
add("username", "", strconv.Quote(view.Username))
|
|
add("role", "", view.Role.String())
|
|
for _, field := range optional {
|
|
if field == "displayName" {
|
|
add(field, "", strconv.Quote(view.DisplayName))
|
|
} else {
|
|
add(field, "", strconv.Quote(view.Email))
|
|
}
|
|
}
|
|
} else {
|
|
add("role", coreuser.RoleFromStore(actual.Role).String(), view.Role.String())
|
|
for _, field := range optional {
|
|
if field == "displayName" {
|
|
add(field, strconv.Quote(actual.Nickname), strconv.Quote(view.DisplayName))
|
|
} else {
|
|
add(field, strconv.Quote(actual.Email), strconv.Quote(view.Email))
|
|
}
|
|
}
|
|
}
|
|
if sendPassword {
|
|
before := ""
|
|
if actual != nil {
|
|
before = writeOnlyPlaceholder
|
|
}
|
|
changes = append(changes, &apipb.FieldChange{Path: "password", Before: before, After: fmt.Sprintf("(write-only, version %d)", version)})
|
|
}
|
|
return changes
|
|
}
|
|
|
|
// planLinkedIdentities plans the identity links of declared users. The user is
|
|
// declared, so the schema layer already guarantees planUsers saw it; the
|
|
// provider must exist after apply; and a subject already linked to another
|
|
// user is never taken over, since the plan cannot know which binding is right.
|
|
func (p *planner) planLinkedIdentities() error {
|
|
for _, declared := range sortedByName(p.desired.Configuration.LinkedIdentities, (*apipb.LinkedIdentity).GetName) {
|
|
name := declared.Name
|
|
userName, providerName := splitLinkedIdentityName(name)
|
|
username := strings.TrimPrefix(userName, coreuser.NamePrefix)
|
|
uid := strings.TrimPrefix(providerName, identityprovider.NamePrefix)
|
|
if !p.providersAfter[uid] {
|
|
p.fail(name, "names %s, which would not exist after apply", providerName)
|
|
continue
|
|
}
|
|
user := p.declaredUsers[username]
|
|
holders, err := p.reader.ListUserIdentities(p.ctx, &store.FindUserIdentity{Provider: &uid, ExternUID: &declared.ExternalUid})
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to read the identity links of %s", providerName)
|
|
}
|
|
if len(holders) > 0 && (user == nil || holders[0].UserID != user.ID) {
|
|
holder, err := p.userName(holders[0].UserID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.fail(name, "the %s subject is already linked to %s; unlink it there first", providerName, holder)
|
|
continue
|
|
}
|
|
|
|
var actual *store.UserIdentity
|
|
if user != nil {
|
|
links, err := p.reader.ListUserIdentities(p.ctx, &store.FindUserIdentity{UserID: &user.ID, Provider: &uid})
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to read the identity links of %s", userName)
|
|
}
|
|
if len(links) > 0 {
|
|
actual = links[0]
|
|
}
|
|
}
|
|
desiredAPI := &apipb.LinkedIdentity{Name: name, ExternalUid: declared.ExternalUid}
|
|
var actualAPI proto.Message
|
|
if actual != nil {
|
|
actualAPI = &apipb.LinkedIdentity{Name: name, ExternalUid: actual.ExternUID}
|
|
}
|
|
changes := diffResource(actualAPI, desiredAPI, nil)
|
|
entry := &storepb.InstanceConfigurationState_ManagedResource{
|
|
ManagedFields: []string{"*"},
|
|
Digest: digest(desiredAPI, p.lifecycle[name]),
|
|
References: []string{providerName},
|
|
}
|
|
op := &operation{
|
|
identity: &store.UserIdentity{Provider: uid, ExternUID: declared.ExternalUid},
|
|
identityUsername: username,
|
|
actualIdentity: actual,
|
|
actualUser: user,
|
|
}
|
|
p.declared(rankLinkedIdentity, name, KindLinkedIdentity, actual != nil, changes, entry, op)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// userName returns the resource name of the stored user with id.
|
|
func (p *planner) userName(id int32) (string, error) {
|
|
users, err := p.reader.ListUsers(p.ctx, &store.FindUser{ID: &id})
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "failed to read user")
|
|
}
|
|
if len(users) == 0 {
|
|
return "a deleted user", nil
|
|
}
|
|
return coreuser.NamePrefix + users[0].Username, nil
|
|
}
|
|
|
|
// storedLinkedIdentity returns the identity link a managed linked identity
|
|
// name describes, or nil when the user or the link is gone.
|
|
func (p *planner) storedLinkedIdentity(name string) (*store.User, *store.UserIdentity, error) {
|
|
userName, providerName := splitLinkedIdentityName(name)
|
|
username := strings.TrimPrefix(userName, coreuser.NamePrefix)
|
|
uid := strings.TrimPrefix(providerName, identityprovider.NamePrefix)
|
|
users, err := p.reader.ListUsers(p.ctx, &store.FindUser{Username: &username})
|
|
if err != nil {
|
|
return nil, nil, errors.Wrap(err, "failed to read user")
|
|
}
|
|
if len(users) == 0 {
|
|
return nil, nil, nil
|
|
}
|
|
links, err := p.reader.ListUserIdentities(p.ctx, &store.FindUserIdentity{UserID: &users[0].ID, Provider: &uid})
|
|
if err != nil {
|
|
return nil, nil, errors.Wrapf(err, "failed to read the identity links of %s", userName)
|
|
}
|
|
if len(links) == 0 {
|
|
return users[0], nil, nil
|
|
}
|
|
return users[0], links[0], nil
|
|
}
|
|
|
|
// planUndeclared handles managed resources no file declares any longer: a
|
|
// removed entry destroys, resets, or releases them; without one, removal was
|
|
// not explicit and the plan fails.
|
|
func (p *planner) planUndeclared() error {
|
|
for _, managed := range p.state.Resources {
|
|
name := managed.Name
|
|
if _, declared := p.desired.Sources[name]; declared {
|
|
continue
|
|
}
|
|
if name == "instance/settings/MEMO_RELATED" {
|
|
change := &apipb.ResourceChange{
|
|
Resource: name, Action: apipb.ResourceChange_RELEASE,
|
|
Message: "reaction configuration is retired; reactions use the full emoji picker",
|
|
}
|
|
p.changes = append(p.changes, rankedChange{rank: rankInstanceSetting, change: change, op: &operation{change: change}})
|
|
continue
|
|
}
|
|
removed := p.removed[name]
|
|
kind, id, err := ParseResourceName(name)
|
|
if err != nil {
|
|
p.fail(name, "the state record names a resource this version cannot manage: %v", err)
|
|
continue
|
|
}
|
|
change := &apipb.ResourceChange{Resource: name}
|
|
op := &operation{change: change, kind: kind}
|
|
rank := map[Kind]int{KindIdentityProvider: rankIdentityProvider, KindInstanceSetting: rankInstanceSetting, KindUser: rankUser, KindLinkedIdentity: rankLinkedIdentity}[kind]
|
|
switch {
|
|
case removed == nil:
|
|
change.Action = apipb.ResourceChange_ERROR
|
|
change.Message = "managed but no longer declared; add a removed entry to destroy or release it"
|
|
p.fail(name, "%s", change.Message)
|
|
case !removed.Destroy:
|
|
change.Action = apipb.ResourceChange_RELEASE
|
|
case managed.PreventDestroy:
|
|
change.Action = apipb.ResourceChange_ERROR
|
|
change.Message = "preventDestroy was set when last applied; apply once without it, then destroy"
|
|
p.fail(name, "%s", change.Message)
|
|
case kind == KindUser:
|
|
// Deleting a user deletes their memos and attachment files and must
|
|
// respect their spaces; that belongs to the deletion flow in Settings.
|
|
change.Action = apipb.ResourceChange_ERROR
|
|
change.Message = "configuration cannot delete a user; release it with destroy false, then delete the user in Settings"
|
|
p.fail(name, "%s", change.Message)
|
|
case kind == KindInstanceSetting:
|
|
change.Action = apipb.ResourceChange_RESET
|
|
op.settingKey = storepb.InstanceSettingKey(storepb.InstanceSettingKey_value[id])
|
|
if id == storepb.InstanceSettingKey_GENERAL.String() {
|
|
p.generalAfter = &storepb.InstanceGeneralSetting{}
|
|
p.generalPlanned = true
|
|
}
|
|
case kind == KindLinkedIdentity:
|
|
user, link, err := p.storedLinkedIdentity(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if link == nil {
|
|
change.Action = apipb.ResourceChange_RELEASE
|
|
change.Message = "already deleted outside the configuration"
|
|
break
|
|
}
|
|
change.Action = apipb.ResourceChange_DESTROY
|
|
rank = rankLinkedIdentityDestroy
|
|
op.actualUser, op.actualIdentity = user, link
|
|
default:
|
|
if !p.providersAfter[id] {
|
|
change.Action = apipb.ResourceChange_RELEASE
|
|
change.Message = "already deleted outside the configuration"
|
|
break
|
|
}
|
|
change.Action = apipb.ResourceChange_DESTROY
|
|
rank = rankIdentityProviderDestroy
|
|
op.providerID = p.providersByUID[id].GetId()
|
|
delete(p.providersAfter, id)
|
|
p.providerDestroyed = true
|
|
}
|
|
p.changes = append(p.changes, rankedChange{rank: rank, change: change, op: op})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// checkAuthentication fails a plan that ends with password sign-in disabled
|
|
// for regular users and no identity provider, when the plan itself touches
|
|
// either. An unrelated plan only warns about a stored state already like that.
|
|
func (p *planner) checkAuthentication() error {
|
|
general := p.generalAfter
|
|
if !p.generalPlanned {
|
|
stored, err := p.reader.GetUncachedInstanceSetting(p.ctx, &store.FindInstanceSetting{Name: storepb.InstanceSettingKey_GENERAL.String()})
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to read GENERAL")
|
|
}
|
|
general = stored.GetGeneralSetting()
|
|
}
|
|
if !general.GetDisallowPasswordAuth() || len(p.providersAfter) > 0 {
|
|
return nil
|
|
}
|
|
const problem = "password sign-in is disabled for regular users and no identity provider would remain"
|
|
if p.generalPlanned || p.providerDestroyed {
|
|
p.message.Errors = append(p.message.Errors, problem)
|
|
} else {
|
|
p.message.Warnings = append(p.message.Warnings, "the stored configuration already has "+problem+"; administrators can still sign in with a password")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *planner) finish() *Plan {
|
|
slices.SortStableFunc(p.changes, func(a, b rankedChange) int {
|
|
if a.rank != b.rank {
|
|
return a.rank - b.rank
|
|
}
|
|
return strings.Compare(a.change.Resource, b.change.Resource)
|
|
})
|
|
writes := false
|
|
plan := &Plan{Message: p.message}
|
|
for _, ranked := range p.changes {
|
|
p.message.ResourceChanges = append(p.message.ResourceChanges, ranked.change)
|
|
plan.operations = append(plan.operations, ranked.op)
|
|
if ranked.change.Action != apipb.ResourceChange_NO_OP {
|
|
writes = true
|
|
}
|
|
}
|
|
if !plan.Valid() {
|
|
return plan
|
|
}
|
|
|
|
slices.SortFunc(p.next, func(a, b *storepb.InstanceConfigurationState_ManagedResource) int {
|
|
return strings.Compare(a.Name, b.Name)
|
|
})
|
|
plan.next = &storepb.InstanceConfigurationState{
|
|
Serial: p.state.Serial,
|
|
ConfigDigest: digest(p.desired.Configuration),
|
|
Resources: p.next,
|
|
}
|
|
p.message.StateRecordChanges = writes || !sameRecord(p.state, plan.next)
|
|
return plan
|
|
}
|
|
|
|
// sameRecord compares the managed resources of two state records, ignoring
|
|
// the apply metadata a plan does not compute. The config digest is left out:
|
|
// it is informational, so a change to it alone, such as a deleted leftover
|
|
// removed entry, is not worth an apply.
|
|
func sameRecord(a, b *storepb.InstanceConfigurationState) bool {
|
|
strip := func(state *storepb.InstanceConfigurationState) *storepb.InstanceConfigurationState {
|
|
stripped := &storepb.InstanceConfigurationState{}
|
|
for _, resource := range state.Resources {
|
|
resource = proto.CloneOf(resource)
|
|
resource.AppliedTs = 0
|
|
stripped.Resources = append(stripped.Resources, resource)
|
|
}
|
|
slices.SortFunc(stripped.Resources, func(x, y *storepb.InstanceConfigurationState_ManagedResource) int {
|
|
return strings.Compare(x.Name, y.Name)
|
|
})
|
|
return stripped
|
|
}
|
|
return proto.Equal(strip(a), strip(b))
|
|
}
|
|
|
|
func sortedByName[T any](items []T, name func(T) string) []T {
|
|
sorted := slices.Clone(items)
|
|
slices.SortFunc(sorted, func(a, b T) int { return strings.Compare(name(a), name(b)) })
|
|
return sorted
|
|
}
|