module

type ApplyUseCase ¶

type ApplyUseCase struct {
	// contains filtered or unexported fields
}

ApplyUseCase — приводит строки каталога модуля к объявленному доставленным манифестом состоянию, ровно если состояние модуля не сдвинулось с плана.

func NewApplyUseCase(d DeliverySource, a CatalogApplier, ops operationRepo, logger *slog.Logger) *ApplyUseCase

func (uc *ApplyUseCase) Execute(
	ctx context.Context,
	module, expectedState string,
	maxResettledRuleRefs, maxResettledRoleVerbs *int32,
) (*operationpb.Operation, error)

func (uc *ApplyUseCase) WithAdminChecker(c adminChecker) *ApplyUseCase

type CatalogApplier ¶

type CatalogApplier interface {
	Apply(ctx context.Context, req modulecatalog.Request) (modulecatalog.Report, error)
}

CatalogApplier — применитель ГЛАГОЛА: сверяет опору всегда и требует подтверждения с потолками.

Тип назван потребностью, а не реализацией: путь старта пользуется ДРУГИМ применителем (`modulecatalog.Applier`), у которого подтверждения нет by construction, и подать его сюда невозможно — их различает ТИП, а не флаг.

type CatalogStateSource ¶

type CatalogStateSource interface {
	ReadLiveCatalog(ctx context.Context) (catalog.Rows, error)
	ReadRetiredCatalog(ctx context.Context) (catalog.Rows, error)
}

CatalogStateSource — обе половины каталога ПЛАТФОРМЫ: живая и снятая.

Обе, а не одна, и не один модуль: опора стража паритета есть литерал платформы целиком, а страж принимает снятую строку СВОЕЙ корзиной. Подавший ему одно живое множество получит законное снятие в недостающих — то есть план объявит отказ там, где применение пройдёт.

type Delivery ¶

type Delivery struct {
	// Declared — посадка объявила каталог доставки. Ложь означает «доставки нет
	// вовсе», а не «доставка пуста».
	Declared bool
	// ManifestsRead — манифестов прочитано (в том числе негодных: они прочитаны,
	// и именно поэтому о них есть что сказать).
	ManifestsRead int
	// Findings — находок обхода. Ненулевое означает «объявлена и сорвана».
	Findings int
	// Manifests — РАЗОБРАННЫЕ годные манифесты.
	Manifests []*manifest.Manifest
}

Delivery — состояние каталога доставки на момент запроса.

Три состояния доставки различимы ЗДЕСЬ, а не в тексте отказа: они чинятся в трёх разных местах — посадкой, источником манифестов и самим манифестом, — и слив их в один отказ, мы отправили бы оператора чинить не то.

type DeliverySource ¶

type DeliverySource interface {
	// Read перечитывает каталог доставки. Перепись возвращается ВСЕГДА,
	// независимо от исхода: без неё «прочитано ноль» неотличимо от «находок
	// ноль».
	Read(ctx context.Context) (Delivery, error)
}

DeliverySource — порт доставки манифестов, ПЕРЕЧИТЫВАЕМОЙ на пути запроса.

Перечитывается, а не берётся снимком старта: снимок разошёлся бы с тем, что применит следующий пуск, и разошёлся бы молча. Манифест телом запроса не приходит вовсе — второй путь доставки, расходящийся с первым, превращает применение в кирпич (страж паритета откажет следующему пуску).

type GetUseCase ¶

type GetUseCase struct {
	// contains filtered or unexported fields
}

GetUseCase — живые строки ОДНОГО модуля.

func NewGetUseCase(c liveSource) *GetUseCase

func (uc *GetUseCase) Execute(ctx context.Context, module string) (*iamv1.ModuleCatalog, error)

func (uc *GetUseCase) WithAdminChecker(c adminChecker) *GetUseCase

type Handler ¶

type Handler struct {
	iamv1.UnimplementedInternalModuleServiceServer
	// contains filtered or unexported fields
}

Handler реализует iamv1.InternalModuleServiceServer.

func NewHandler(plan *PlanUseCase, apply *ApplyUseCase, get *GetUseCase, list *ListUseCase) *Handler

func (h *Handler) Apply(ctx context.Context, req *iamv1.ApplyModuleRequest) (*operationpb.Operation, error)

func (h *Handler) Get(ctx context.Context, req *iamv1.GetModuleRequest) (*iamv1.ModuleCatalog, error)

func (h *Handler) List(ctx context.Context, _ *iamv1.ListModulesRequest) (*iamv1.ListModulesResponse, error)

func (h *Handler) Plan(ctx context.Context, req *iamv1.PlanModuleRequest) (*iamv1.PlanModuleResponse, error)

type ListUseCase ¶

type ListUseCase struct {
	// contains filtered or unexported fields
}

ListUseCase — живые модули каталога с числами.

func NewListUseCase(c liveSource) *ListUseCase

func (uc *ListUseCase) Execute(ctx context.Context) (*iamv1.ListModulesResponse, error)

func (uc *ListUseCase) WithAdminChecker(c adminChecker) *ListUseCase

type PlanState ¶

type PlanState struct {
	// ExpectedState — отпечаток состояния каталога модуля, непрозрачный для
	// вызывающего и возвращаемый им дословно в `Apply`. Контракт — РАВЕНСТВО и
	// ничего кроме; способ вычисления есть деталь реализации адаптера.
	ExpectedState string
	// Resettled — ОЦЕНКА переселения по популяциям на момент плана.
	Resettled modulecatalog.Resettled
	// Pruned — ОЦЕНКА вырезания третьей проекции, тремя величинами.
	Pruned modulecatalog.Pruned
}

PlanState — плановая сторона состояния каталога модуля, снятая ОДНИМ чтением.

Одним, а не тремя: отпечаток и оценки последствий обязаны описывать ОДНО состояние. Собранные из трёх моментов, они описывали бы состояние, которого не было ни в один из них.

type PlanStateSource ¶

type PlanStateSource interface {
	// PlanState читает отпечаток состояния модуля и оценивает последствия снятия
	// названных строк.
	PlanState(ctx context.Context, module string,
		staleResources []catalog.ResourceRow, staleVerbs []catalog.VerbRow) (PlanState, error)
}

PlanStateSource — производитель плановой стороны.

Почему это порт, а не вычисление здесь ¶

Отпечаток производится ТЕМ ЖЕ выражением, которым его сверяет применитель (`ConfirmModuleState`), а оценки последствий — тем же отбором, каким переселяет применитель. Посчитав их здесь, на языке Go, мы завели бы вторую копию обоих предикатов, и разошлись бы они молча — то есть ровно там, где расхождение не видно: план обещал бы одно, применение делало другое, и оба были бы «правы».

Непровязанный порт — ОТКАЗ, а не разрешение ¶

`nil` означает, что производителя плановой стороны в этой сборке нет. Тогда `Plan` отказывает, называя причину. Вернуть вместо этого нули значило бы солгать о последствиях: ноль в `resettled…AtPlanTime` есть УТВЕРЖДЕНИЕ «ни одного права не отберут», а не «мы не считали».

type PlanUseCase ¶

type PlanUseCase struct {
	// contains filtered or unexported fields
}

PlanUseCase — что применение доставленного манифеста этого модуля СДЕЛАЛО БЫ.

func NewPlanUseCase(d DeliverySource, c CatalogStateSource, p PlanStateSource) *PlanUseCase

func (uc *PlanUseCase) Execute(ctx context.Context, module string) (*iamv1.PlanModuleResponse, error)

func (uc *PlanUseCase) WithAdminChecker(c adminChecker) *PlanUseCase