package versions import ( "context" "encoding/json" "errors" "fmt" "strings" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds" ) // The builder's tools of its versions (design 51 *Events of the builder*, *Tools of the builder*). const ( VersionsTool = "builder_versions" PublishAgainTool = "builder_publish_again" FloorAgainTool = "builder_floor_again" OldFormTool = "builder_old_form" // OldFormClosedEvent is the builder's own family `version`, kept seven days, // apart from its builds' ends, so a waiter on a build's end does not wake on them. OldFormClosedEvent = "version.old-form-closed" ) // Reader reads the state as the tools bundle may: every key, and one; and, where All is set, the state's values in one page, // one request for many (design 47 H H-A-290 (5), H-A-292). type Reader struct { Keys func() ([]string, error) Get func(key string) (json.RawMessage, bool, error) // All is one page of the state's values; nil, or an error satisfying errors.Is(err, errors.ErrUnsupported), reads key by key. All func() (StatePage, error) } // StatePage is one page of a state (H-A-292, H-A-293): its values, and, when the state holds more than the page, More with the // state's size as its info says it (Keys, Bytes; InfoWords when the info cannot be read). No second page is asked. type StatePage struct { Values map[string]json.RawMessage More bool Keys, Bytes uint64 InfoWords string } // StateCapped is what an answer says of a state it read only the first page of (H-A-293): how many keys it read, and the // state's size from its info. type StateCapped struct { State string `json:"state"` KeysRead int `json:"keys-read"` StateKeys uint64 `json:"state-keys"` StateBytes uint64 `json:"state-bytes"` InfoWords string `json:"info,omitempty"` } // values is the state's values: one page where the reader can (capped says what a page past the state's end left out), else // key by key. func (r Reader) values(state string) (map[string]json.RawMessage, *StateCapped, error) { if r.All != nil { pg, err := r.All() if !errors.Is(err, errors.ErrUnsupported) { if err != nil || !pg.More { return pg.Values, nil, err } return pg.Values, &StateCapped{State: state, KeysRead: len(pg.Values), StateKeys: pg.Keys, StateBytes: pg.Bytes, InfoWords: pg.InfoWords}, nil } } keys, err := r.Keys() if err != nil { return nil, nil, err } out := make(map[string]json.RawMessage, len(keys)) for _, k := range keys { raw, ok, err := r.Get(k) if err != nil || !ok { continue } out[k] = raw } return out, nil, nil } // readStore is a Store over a Reader that refuses every write: the tools bundle only reads versions. type readStore struct{ r Reader } var errReadOnly = errors.New("the versions are written by the builder alone") func (s readStore) Get(_ context.Context, key string) ([]byte, uint64, bool, error) { v, ok, err := s.r.Get(key) return v, 0, ok, err } func (readStore) Create(context.Context, string, []byte) (uint64, error) { return 0, errReadOnly } func (readStore) Update(context.Context, string, []byte, uint64) (uint64, error) { return 0, errReadOnly } func (s readStore) KeysOf(_ context.Context, filter string) ([]string, error) { all, err := s.r.Keys() if err != nil { return nil, err } var out []string for _, k := range all { if FilterMatches(filter, k) { out = append(out, k) } } return out, nil } // VersionsAnswer is what builder_versions answers. type VersionsAnswer struct { Name string `json:"name"` Versions []Entry `json:"versions"` // Asked, Recorded and Why answer a holder's question for one version and digest (ADR 0605 §4). Asked string `json:"asked,omitempty"` Recorded *bool `json:"recorded,omitempty"` Why string `json:"why,omitempty"` // Reserved is what the seat mesh-builds' verb reserved answers for the name (and version): the reserved or released version // with each artifact's digest, or its error (design 47 G §572, §582). Reserved *meshbuilds.ReservedAnswer `json:"reserved,omitempty"` } // AnswerVersions is builder_versions: a name's versions in order, in one call; with a version (and a digest), whether // the builder numbered it with that digest, which the holder asks before it stores (ADR 0605 §4). func AnswerVersions(ctx context.Context, r Reader, name, version, digest string) (VersionsAnswer, error) { name = strings.TrimSpace(name) if name == "" { return VersionsAnswer{}, errors.New("name is required: the package, image, bundle or archive name") } v := Versions{Store: readStore{r}} all, err := v.Of(ctx, name) if err != nil { return VersionsAnswer{}, err } out := VersionsAnswer{Name: name, Versions: all} if out.Versions == nil { out.Versions = []Entry{} } if version = strings.TrimSpace(version); version != "" { _, ok, why, err := v.Recorded(ctx, name, version, strings.TrimSpace(digest)) if err != nil { return VersionsAnswer{}, fmt.Errorf("%s@%s: %w", name, version, err) } out.Asked, out.Recorded, out.Why = version, &ok, why } return out, nil } // VersionsDescription is builder_versions' description. const VersionsDescription = "A name's versions as the builder numbered them (its state versions, design 51): every trunk and tagged " + "version of a package, image, bundle or archive in order, each with its kind, series, fingerprint, commit, source revision, digest, " + "seat, state (numbered, published, refused with its reason, removed with its time, reason and the event that removed it, or kept: its seat kept it whole on remove, its digest shared, with the reason and the other tags naming it, kept_with) and when. " + "With version, and digest, it also answers recorded: whether the builder numbered that version with that digest, and why not: the " + "question a registry seat's holder asks before it stores a publish (ADR 0605 §4). Read-only."