Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

4.2 KB
Raw Blame
package api

import (
	"context"
	stderrors "errors"
	"strings"
	"time"

	"google.golang.org/genproto/googleapis/rpc/errdetails"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/timestamppb"

	"github.com/usememos/memos/core/configuration"
	apipb "github.com/usememos/memos/proto/gen/api"
	"github.com/usememos/memos/store"
)

// reasonManagedByConfiguration is the ErrorInfo reason of a write refused
// because declarative configuration manages what it would change.
const reasonManagedByConfiguration = "MANAGED_BY_CONFIGURATION"

func (s *APIService) GetConfigurationStatus(ctx context.Context, _ *apipb.GetConfigurationStatusRequest) (*apipb.ConfigurationStatus, error) {
	user, err := s.fetchCurrentUser(ctx)
	if err != nil {
		return nil, status.Errorf(codes.Internal, "failed to get current user: %v", err)
	}
	if user == nil {
		return nil, status.Errorf(codes.Unauthenticated, "user not authenticated")
	}
	if user.Role != store.RoleAdmin {
		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
	}
	state, err := s.Store.GetConfigurationState(ctx)
	if err != nil {
		return nil, status.Errorf(codes.Internal, "failed to read the configuration state: %v", err)
	}
	result := &apipb.ConfigurationStatus{
		Serial:       state.Serial,
		ConfigDigest: state.ConfigDigest,
		AppliedBy:    state.AppliedBy,
		Version:      state.Version,
	}
	if state.AppliedTs != 0 {
		result.ApplyTime = timestamppb.New(time.Unix(state.AppliedTs, 0))
	}
	for _, resource := range state.Resources {
		result.ManagedResources = append(result.ManagedResources, &apipb.ConfigurationStatus_ManagedResource{
			Resource:      resource.Name,
			Source:        resource.Source,
			ManagedFields: resource.ManagedFields,
			IgnoredFields: resource.IgnoredFields,
		})
	}
	return result, nil
}

// checkManagedChange refuses a write that would change fields of a resource
// the configuration manages; changed lists the JSON-name paths the write
// changes. The configuration state is read from the database, so every
// replica enforces ownership whether or not it read the files.
func (s *APIService) checkManagedChange(ctx context.Context, resource string, changed []string) error {
	if len(changed) == 0 {
		// A write that changes nothing is never refused.
		return nil
	}
	state, err := s.Store.GetConfigurationState(ctx)
	if err != nil {
		return status.Errorf(codes.Internal, "failed to read the configuration state: %v", err)
	}
	return managedStatus(configuration.CheckChange(state, resource, changed))
}

// checkManagedExistence refuses creating or deleting a resource the
// configuration manages.
func (s *APIService) checkManagedExistence(ctx context.Context, resource string) error {
	state, err := s.Store.GetConfigurationState(ctx)
	if err != nil {
		return status.Errorf(codes.Internal, "failed to read the configuration state: %v", err)
	}
	return managedStatus(configuration.CheckExistence(state, resource))
}

// checkManagedReference refuses renaming or deleting a resource that a
// resource the configuration manages names, such as a user a managed
// usage-limits setting lists.
func (s *APIService) checkManagedReference(ctx context.Context, resource string) error {
	state, err := s.Store.GetConfigurationState(ctx)
	if err != nil {
		return status.Errorf(codes.Internal, "failed to read the configuration state: %v", err)
	}
	return managedStatus(configuration.CheckReference(state, resource))
}

// managedStatus turns a refusal into FAILED_PRECONDITION with an ErrorInfo
// naming the resource, the file that declares it, and the fields.
func managedStatus(err error) error {
	var managed *configuration.ManagedError
	if !stderrors.As(err, &managed) {
		return err
	}
	st := status.New(codes.FailedPrecondition, managed.Error())
	metadata := map[string]string{
		"resource": managed.Resource,
		"source":   managed.Source,
		"fields":   strings.Join(managed.Fields, ","),
	}
	if managed.ReferencedBy != "" {
		metadata["referenced_by"] = managed.ReferencedBy
	}
	detailed, detailErr := st.WithDetails(&errdetails.ErrorInfo{
		Reason:   reasonManagedByConfiguration,
		Domain:   errorInfoDomain,
		Metadata: metadata,
	})
	if detailErr != nil {
		return st.Err()
	}
	return detailed.Err()
}