diff --git a/README.md b/README.md index 0d46dfb..e78d21c 100644 --- a/README.md +++ b/README.md @@ -164,3 +164,64 @@ EBUILD_TARGETS=http://local-mirror:8080/gitweb.cgi?p=EdgeTX/cloudbuild.git;a=blo # This is the default refresh interval in seconds EBUILD_TARGETS_REFRESH_INTERVAL=300 ``` + +## Limiting targets and flag values to releases + +Some radios, options and option values only exist in some EdgeTX releases. +In `targets.json` they can be limited with +[semver constraints](https://github.com/Masterminds/semver#checking-version-constraints), +checked against each release's version (`sem_ver` if set, e.g. `nightly`): + +| Field | On | Limits | +|---|---|---| +| `version_supported` | a target | the target | +| `version_supported` | a flag | the whole flag, i.e. every value in that definition | +| `values_version_supported` | a flag | individual values, as a map from value to constraint | + +```json +"targets": { + "newradio": { "description": "Example New Radio", "version_supported": ">= 3.0.0-0" } +}, +"flags": { + "power_led_blue": { + "build_flag": "POWER_LED_BLUE", + "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" + } +}, +"tags": { + "colorlcd": { + "flags": { + "language": { + "values": ["AR", "CN"], + "values_version_supported": { "AR": ">= 3.0.0-0" } + } + } + } +} +``` + +- A flag's `version_supported` and `values_version_supported` can be + combined: a value is supported only if both allow the release. Keys of + `values_version_supported` must be listed in `values`. +- Flags are defined globally and per tag. A constraint only applies to the + definition it's in, so a flag defined in several places is limited in + each. +- Build requests that use an unsupported target, flag or value for the + requested release are rejected. +- The API exposes the result per release as `exclude_targets` and + `exclude_flags`, so clients can hide what a release can't build. A flag + with all its values excluded is dropped by clients. + +**Use `-0` on the version in constraints** (`>= 3.0.0-0`, `< 3.0.0-0`) +when pre-releases should follow the same rule as releases. A constraint +without a pre-release part never matches pre-releases, so if pre-releases +are listed in `releases`: + +- `>= 3.0.0` excludes `v3.0.0-rc1`; `>= 3.0.0-0` includes it. +- `< 3.0.0` also excludes `v2.12.6-rc1`; `< 3.0.0-0` includes 2.x + pre-releases and excludes 3.0 ones. + +`-0` is the lowest possible pre-release, so `3.0.0-0` sits just before every +3.0 pre-release. This only matters for releases with a pre-release version: +`nightly` uses `sem_ver` (e.g. `v3.0.0`), which isn't one. diff --git a/artifactory/build_request.go b/artifactory/build_request.go index a99b520..bd1a711 100644 --- a/artifactory/build_request.go +++ b/artifactory/build_request.go @@ -16,6 +16,8 @@ var ( ErrReleaseNotSupported = errors.New("release not supported") ErrTargetNotSupported = errors.New("target not supported") ErrOptionFlagNotSupported = errors.New("option flag not supported") + + ErrOptionFlagNotSupportedByRelease = errors.New("option flag not supported by release") ) type OptionFlag struct { @@ -43,6 +45,10 @@ func (e *BuildRequestError) Error() string { return fmt.Sprintf("%s: %s", e.Err.Error(), e.What) } +func (e *BuildRequestError) Unwrap() error { + return e.Err +} + func NewBuildRequest() *BuildRequest { return &BuildRequest{ defs: targets.GetTargets(), @@ -78,6 +84,16 @@ func (req *BuildRequest) Validate() error { What: flag.String(), } } + ok, constraint := req.defs.IsOptionFlagSupportedByRelease( + req.Target, flag.Name, flag.Value, req.Release, + ) + if !ok { + return &BuildRequestError{ + Err: ErrOptionFlagNotSupportedByRelease, + What: fmt.Sprintf("%s requires release %s, got %s", + flag.String(), constraint, req.Release), + } + } } return nil } diff --git a/artifactory/build_request_test.go b/artifactory/build_request_test.go index 71b55fe..2febc03 100644 --- a/artifactory/build_request_test.go +++ b/artifactory/build_request_test.go @@ -4,6 +4,7 @@ import ( "testing" "github.com/edgetx/cloudbuild/artifactory" + "github.com/edgetx/cloudbuild/targets" "github.com/stretchr/testify/assert" ) @@ -36,3 +37,53 @@ func TestBuildHashIsTheSameForDiffOrderFlagArrays(t *testing.T) { assert.Equal(t, req1.HashTargetAndFlags(), req2.HashTargetAndFlags()) } + +func TestValidateOptionFlagRelease(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(`{ + "releases": { + "nightly": { "sha": "000", "sem_ver": "v3.0.0" }, + "v2.12.5": { "sha": "211" } + }, + "flags": { + "language": { "build_flag": "TRANSLATIONS", "values": ["EN"] }, + "power_led_blue": { + "build_flag": "POWER_LED_BLUE", "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" + } + }, + "tags": { + "colorlcd": { "flags": { "language": { + "values": ["AR"], "values_version_supported": { "AR": ">= 3.0.0-0" } + }}} + }, + "targets": { + "tx16s": { "description": "TX16S", "tags": ["colorlcd"] }, + "x7": { "description": "X7" } + } + }`), "") + assert.Nil(t, err) + + prev := targets.GetTargets() + targets.SetTargets(defs) + defer targets.SetTargets(prev) + + ar := []artifactory.OptionFlag{{Name: "language", Value: "AR"}} + + assert.Nil(t, artifactory.NewBuildRequestWithParams("nightly", "tx16s", ar).Validate()) + + err = artifactory.NewBuildRequestWithParams("v2.12.5", "tx16s", ar).Validate() + assert.ErrorIs(t, err, artifactory.ErrOptionFlagNotSupportedByRelease) + assert.EqualError(t, err, + "option flag not supported by release: language=AR requires release >=3.0.0-0, got v2.12.5") + + // value unknown for the target: unchanged error + err = artifactory.NewBuildRequestWithParams("nightly", "x7", ar).Validate() + assert.ErrorIs(t, err, artifactory.ErrOptionFlagNotSupported) + + // whole flag limited to releases before 3.0 + blue := []artifactory.OptionFlag{{Name: "power_led_blue", Value: "NO"}} + assert.Nil(t, artifactory.NewBuildRequestWithParams("v2.12.5", "x7", blue).Validate()) + err = artifactory.NewBuildRequestWithParams("nightly", "x7", blue).Validate() + assert.EqualError(t, err, + "option flag not supported by release: power_led_blue=NO requires release <3.0.0-0, got nightly") +} diff --git a/doc/PublicAPI.md b/doc/PublicAPI.md index 33b78c7..8abf3d4 100644 --- a/doc/PublicAPI.md +++ b/doc/PublicAPI.md @@ -7,6 +7,17 @@ This endpoint allows for retrieving the supported targets and build options. It returns the configured `targets.json` (see [here](../targets.json)). +Each release also includes what it can't build, computed from the +`version_supported` and `values_version_supported` constraints (see the +[README](../README.md#limiting-targets-and-flag-values-to-releases)): + +- `exclude_targets`: targets not supported by this release. +- `exclude_flags`: option flag values not supported by this release, as a map + from flag name to values, e.g. `{"language": ["AR"]}`. + +Both are omitted when empty. Clients should hide these for the selected +release; build requests using them are rejected. + #### CURL ```sh diff --git a/targets.json b/targets.json index a8501a5..2c728e5 100644 --- a/targets.json +++ b/targets.json @@ -88,14 +88,17 @@ "FI", "FR", "IT", - "KO", "NL", "PL", "PT", "RU", "SE", "UA" - ] + ], + "values_version_supported": { + "RU": ">= 2.10.0-0", + "UA": ">= 2.10.0-0" + } }, "fai_mode": { "build_flag": "FAI", @@ -107,7 +110,8 @@ }, "power_led_blue": { "build_flag": "POWER_LED_BLUE", - "values": ["YES", "NO"] + "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" }, "pxx1": { "build_flag": "PXX1", @@ -138,7 +142,12 @@ "colorlcd": { "flags": { "language": { - "values": ["AR", "CN", "HE", "JP", "SK", "TW"] + "values": ["AR", "CN", "HE", "JP", "KO", "SK", "TW"], + "values_version_supported": { + "AR": ">= 3.0.0-0", + "HE": ">= 2.9.0-0", + "KO": ">= 2.11.0-0" + } } } }, @@ -178,7 +187,8 @@ "flags": { "kcx_btaudio": { "build_flag": "KCX_BTAUDIO", - "values": ["YES"] + "values": ["YES"], + "version_supported": ">= 3.0.0-0" } } } diff --git a/targets/targets_def.go b/targets/targets_def.go index a5bcb37..c0654f9 100644 --- a/targets/targets_def.go +++ b/targets/targets_def.go @@ -27,9 +27,10 @@ var ( // absurdly high version. NightlyVersion = semver.New(math.MaxUint64, 0, 0, "", "") - ErrMissingSHA = errors.New("missing SHA") - ErrMissingRef = errors.New("missing ref") - ErrInvalidSchema = errors.New("invalid URL schema") + ErrMissingSHA = errors.New("missing SHA") + ErrMissingRef = errors.New("missing ref") + ErrInvalidSchema = errors.New("invalid URL schema") + ErrInvalidValuesVersionSupported = errors.New("values_version_supported for undefined value") ) type RemoteAPI struct { @@ -40,8 +41,11 @@ type RemoteAPI struct { type Release struct { SHA string `json:"sha"` ExcludeTargets []string `json:"exclude_targets,omitempty"` - BuildContainer string `json:"build_container,omitempty"` - SemVer string `json:"sem_ver,omitempty"` + // ExcludeFlags maps an option flag name to the values that this release + // does not support (computed from the OptionFlag version constraints). + ExcludeFlags map[string][]string `json:"exclude_flags,omitempty"` + BuildContainer string `json:"build_container,omitempty"` + SemVer string `json:"sem_ver,omitempty"` update bool version *semver.Version } @@ -49,6 +53,14 @@ type Release struct { type OptionFlag struct { BuildFlag string `json:"build_flag,omitempty"` Values []string `json:"values"` + // VersionSupported optionally limits the whole flag (every value in this + // definition) to the releases matching a semver constraint, like + // Target.VersionSupported (e.g. "< 3.0.0-0"). + VersionSupported *semver.Constraints `json:"version_supported,omitempty"` + // ValuesVersionSupported optionally limits individual values, as a map + // from value to constraint (e.g. {"AR": ">= 3.0.0-0"}). Values without an + // entry are only limited by VersionSupported. + ValuesVersionSupported map[string]semver.Constraints `json:"values_version_supported,omitempty"` } type BuildFlags map[string]string @@ -167,6 +179,31 @@ func (opts OptionFlags) HasOptionValue(name, value string) bool { return false } +// releaseConstraint reports whether value may be used with release r. When +// it may not, the constraint that excludes it is returned: the whole-flag +// one first, then the value's own. +func (opt *OptionFlag) releaseConstraint(value string, r *Release) (bool, string) { + if opt.VersionSupported != nil && !opt.VersionSupported.Check(r.version) { + return false, opt.VersionSupported.String() + } + if c, ok := opt.ValuesVersionSupported[value]; ok && !c.Check(r.version) { + return false, c.String() + } + return true, "" +} + +func (opts OptionFlags) validateValuesVersionSupported(scope string) error { + for name, opt := range opts { + for value := range opt.ValuesVersionSupported { + if !slices.Contains(opt.Values, value) { + return fmt.Errorf("%s: flag %q, value %q: %w", + scope, name, value, ErrInvalidValuesVersionSupported) + } + } + } + return nil +} + func (target *Target) SupportsRelease(r *Release) bool { if len(target.VersionSupported.String()) > 0 { return target.VersionSupported.Check(r.version) @@ -186,7 +223,11 @@ func (def *TargetsDef) UnmarshalJSON(text []byte) error { if err := tmp.fillSemVer(); err != nil { return err } + if err := tmp.validateValuesVersionSupported(); err != nil { + return err + } tmp.fillExcludeTargets() + tmp.fillExcludeFlags() *def = tmp return nil @@ -244,6 +285,48 @@ func (def *TargetsDef) fillExcludeTargets() { } } +func (def *TargetsDef) validateValuesVersionSupported() error { + if err := def.OptionFlags.validateValuesVersionSupported("flags"); err != nil { + return err + } + for name, tag := range def.Tags { + if err := tag.Flags.validateValuesVersionSupported("tags." + name); err != nil { + return err + } + } + return nil +} + +// fillExcludeFlags computes Release.ExcludeFlags: for each release, the flag +// values (global or from any tag) excluded by their flag's version_supported +// or their own values_version_supported constraint. +func (def *TargetsDef) fillExcludeFlags() { + for k := range def.Releases { + r := def.Releases[k] + r.ExcludeFlags = nil + exclude := func(opts OptionFlags) { + for name, opt := range opts { + for _, value := range opt.Values { + if ok, _ := opt.releaseConstraint(value, r); !ok { + if r.ExcludeFlags == nil { + r.ExcludeFlags = make(map[string][]string) + } + r.ExcludeFlags[name] = append(r.ExcludeFlags[name], value) + } + } + } + } + exclude(def.OptionFlags) + for _, tag := range def.Tags { + exclude(tag.Flags) + } + for name, values := range r.ExcludeFlags { + slices.Sort(values) + r.ExcludeFlags[name] = slices.Compact(values) + } + } +} + func (def *TargetsDef) fillSemVer() error { for k := range def.Releases { r := def.Releases[k] @@ -285,23 +368,60 @@ func (def *TargetsDef) IsTargetSupported(name, ref string) bool { return target.SupportsRelease(r) } -func (def *TargetsDef) IsOptionFlagSupported(target, name, value string) bool { - if def.OptionFlags.HasOptionValue(name, value) { - return true +// optionFlagDefs returns the definitions of flag name that apply to target: +// the global one first (if any), followed by those of the target's tags. +func (def *TargetsDef) optionFlagDefs(target, name string) []OptionFlag { + defs := make([]OptionFlag, 0, 1) + if opt, ok := def.OptionFlags[name]; ok { + defs = append(defs, opt) } - if t, ok := def.Targets[target]; ok { for _, tag := range t.Tags { - tagDef, ok := def.Tags[tag] - if ok && tagDef.Flags.HasOptionValue(name, value) { - return true + if tagDef, ok := def.Tags[tag]; ok { + if opt, ok := tagDef.Flags[name]; ok { + defs = append(defs, opt) + } } } } + return defs +} +// IsOptionFlagSupported reports whether value is a known value of flag name +// for target, regardless of the release. +func (def *TargetsDef) IsOptionFlagSupported(target, name, value string) bool { + for _, opt := range def.optionFlagDefs(target, name) { + if slices.Contains(opt.Values, value) { + return true + } + } return false } +// IsOptionFlagSupportedByRelease reports whether value of flag name may be +// used for target at release ref, i.e. no applicable definition listing that +// value has a constraint excluding the release. When it may not, the +// offending constraint is returned (empty if ref is unknown). +func (def *TargetsDef) IsOptionFlagSupportedByRelease(target, name, value, ref string) (bool, string) { + v, err := NewVersionRef(ref) + if err != nil { + return false, "" + } + r, ok := def.Releases[*v] + if !ok { + return false, "" + } + for _, opt := range def.optionFlagDefs(target, name) { + if !slices.Contains(opt.Values, value) { + continue + } + if ok, c := opt.releaseConstraint(value, r); !ok { + return false, c + } + } + return true, "" +} + func (def *TargetsDef) GetCommitHashByRef(ref string) string { v, err := NewVersionRef(ref) if err != nil { diff --git a/targets/targets_test.go b/targets/targets_test.go index 63ca1fa..e4e3878 100644 --- a/targets/targets_test.go +++ b/targets/targets_test.go @@ -1,6 +1,9 @@ package targets_test import ( + "encoding/json" + "os" + "slices" "testing" semver "github.com/Masterminds/semver/v3" @@ -124,3 +127,338 @@ func TestExcludeTargets(t *testing.T) { assert.Nil(t, err) assert.Equal(t, []string{"t123", "x123"}, excl) } + +var flagConstraintsJSON = `{ + "releases": { + "nightly": { "sha": "000", "sem_ver": "v3.0.0" }, + "v3.0.0": { "sha": "300" }, + "v3.0.0-rc1": { "sha": "301" }, + "v2.12.6-rc1": { "sha": "212" }, + "v2.12.5": { "sha": "211" } + }, + "flags": { + "language": { + "build_flag": "TRANSLATIONS", + "values": ["EN", "FR"], + "values_version_supported": { "FR": "< 2.12.5" } + } + }, + "tags": { + "colorlcd": { + "flags": { + "language": { + "values": ["AR", "CN"], + "values_version_supported": { "AR": ">= 3.0.0-0" } + } + } + } + }, + "targets": { + "color": { "description": "Color radio", "tags": ["colorlcd"] }, + "bw": { "description": "B&W radio" } + } +}` + +func TestOptionFlagVersionSupported(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") + assert.Nil(t, err) + + tests := []struct { + target, value, ref string + supported bool + constraint string + }{ + // unconstrained values work everywhere + {"color", "CN", "v2.12.5", true, ""}, + {"color", "EN", "v2.12.5", true, ""}, + // AR only from 3.0.0, including its pre-releases and nightly + {"color", "AR", "v2.12.5", false, ">=3.0.0-0"}, + {"color", "AR", "v2.12.6-rc1", false, ">=3.0.0-0"}, + {"color", "AR", "v3.0.0-rc1", true, ""}, + {"color", "AR", "v3.0.0", true, ""}, + {"color", "AR", "nightly", true, ""}, + // global version_supported constraints apply to every target + {"bw", "FR", "v2.12.5", false, "<2.12.5"}, + {"color", "FR", "nightly", false, "<2.12.5"}, + // unknown release + {"color", "CN", "v9.9.9", false, ""}, + } + for _, tt := range tests { + ok, c := defs.IsOptionFlagSupportedByRelease(tt.target, "language", tt.value, tt.ref) + assert.Equal(t, tt.supported, ok, "%s %s@%s", tt.target, tt.value, tt.ref) + assert.Equal(t, tt.constraint, c, "%s %s@%s", tt.target, tt.value, tt.ref) + } + + // release-independent check is unchanged + assert.True(t, defs.IsOptionFlagSupported("color", "language", "AR")) + assert.False(t, defs.IsOptionFlagSupported("bw", "language", "AR")) +} + +func TestExcludeFlags(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") + assert.Nil(t, err) + + assert.Equal(t, map[string][]string{"language": {"AR", "FR"}}, defs.Releases[ref(t, "v2.12.5")].ExcludeFlags) + assert.Equal(t, map[string][]string{"language": {"AR", "FR"}}, defs.Releases[ref(t, "v2.12.6-rc1")].ExcludeFlags) + assert.Equal(t, map[string][]string{"language": {"FR"}}, defs.Releases[ref(t, "v3.0.0-rc1")].ExcludeFlags) + assert.Equal(t, map[string][]string{"language": {"FR"}}, defs.Releases[ref(t, "nightly")].ExcludeFlags) + + // no constraints: no exclude_flags at all + defs, err = targets.ReadTargetsDefFromBytes([]byte(targetsJSON), "") + assert.Nil(t, err) + for _, r := range defs.Releases { + assert.Nil(t, r.ExcludeFlags) + } +} + +func TestFlagVersionSupportedJSON(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") + assert.Nil(t, err) + + data, err := json.Marshal(defs) + assert.Nil(t, err) + + var out struct { + Releases map[string]struct { + ExcludeFlags map[string][]string `json:"exclude_flags"` + } `json:"releases"` + Tags map[string]struct { + Flags map[string]map[string]any `json:"flags"` + } `json:"tags"` + } + assert.Nil(t, json.Unmarshal(data, &out)) + assert.Equal(t, []string{"AR", "FR"}, out.Releases["v2.12.5"].ExcludeFlags["language"]) + assert.Equal(t, + map[string]any{"AR": ">=3.0.0-0"}, + out.Tags["colorlcd"].Flags["language"]["values_version_supported"]) + + // flags without constraints don't grow a new field, and releases don't + // get exclude_flags (targets have their own, unrelated version_supported) + defs, err = targets.ReadTargetsDefFromBytes([]byte(`{ + "releases": { "v1.0.0": { "sha": "1" } }, + "flags": { "language": { "build_flag": "TRANSLATIONS", "values": ["EN"] } }, + "tags": { "colorlcd": { "flags": { "language": { "values": ["CN"] } } } }, + "targets": { "t1": { "description": "T1", "tags": ["colorlcd"] } } + }`), "") + assert.Nil(t, err) + data, err = json.Marshal(defs) + assert.Nil(t, err) + var plain struct { + Flags map[string]map[string]any `json:"flags"` + Tags map[string]struct { + Flags map[string]map[string]any `json:"flags"` + } `json:"tags"` + } + assert.Nil(t, json.Unmarshal(data, &plain)) + for _, key := range []string{"version_supported", "values_version_supported"} { + assert.NotContains(t, plain.Flags["language"], key) + assert.NotContains(t, plain.Tags["colorlcd"].Flags["language"], key) + } + assert.NotContains(t, string(data), "exclude_flags") +} + +var wholeFlagJSON = `{ + "releases": { + "nightly": { "sha": "0", "sem_ver": "v3.0.0" }, + "v3.0.0-rc1": { "sha": "1" }, + "v2.12.6-rc1": { "sha": "2" }, + "v2.12.5": { "sha": "3" }, + "v2.10.6": { "sha": "4" } + }, + "flags": { + "power_led_blue": { + "build_flag": "POWER_LED_BLUE", + "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" + }, + "new_opt": { + "build_flag": "NEW_OPT", + "values": ["YES", "NO", "X"], + "version_supported": ">= 2.12.0-0", + "values_version_supported": { "X": ">= 3.0.0-0" } + } + }, + "targets": { "t": { "description": "T" } } +}` + +func TestWholeFlagVersionSupported(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(wholeFlagJSON), "") + assert.Nil(t, err) + + tests := []struct { + flag, value, ref string + supported bool + constraint string + }{ + // whole flag removed from 3.0, pre-releases included + {"power_led_blue", "YES", "v2.12.5", true, ""}, + {"power_led_blue", "NO", "v2.12.6-rc1", true, ""}, + {"power_led_blue", "YES", "v3.0.0-rc1", false, "<3.0.0-0"}, + {"power_led_blue", "NO", "nightly", false, "<3.0.0-0"}, + // flag from 2.12 plus one value from 3.0: the flag limit is checked first + {"new_opt", "YES", "v2.10.6", false, ">=2.12.0-0"}, + {"new_opt", "X", "v2.10.6", false, ">=2.12.0-0"}, + {"new_opt", "YES", "v2.12.5", true, ""}, + {"new_opt", "X", "v2.12.5", false, ">=3.0.0-0"}, + {"new_opt", "X", "nightly", true, ""}, + } + for _, tt := range tests { + ok, c := defs.IsOptionFlagSupportedByRelease("t", tt.flag, tt.value, tt.ref) + assert.Equal(t, tt.supported, ok, "%s=%s @ %s", tt.flag, tt.value, tt.ref) + assert.Equal(t, tt.constraint, c, "%s=%s @ %s", tt.flag, tt.value, tt.ref) + } + + // clients drop a flag whose values are all excluded + excl := func(release string) map[string][]string { + return defs.Releases[ref(t, release)].ExcludeFlags + } + assert.Equal(t, map[string][]string{"new_opt": {"NO", "X", "YES"}}, excl("v2.10.6")) + assert.Equal(t, map[string][]string{"new_opt": {"X"}}, excl("v2.12.5")) + assert.Equal(t, map[string][]string{"power_led_blue": {"NO", "YES"}}, excl("nightly")) + + // served as a plain string, like a target's version_supported + data, err := json.Marshal(defs) + assert.Nil(t, err) + var out struct { + Flags map[string]map[string]any `json:"flags"` + } + assert.Nil(t, json.Unmarshal(data, &out)) + assert.Equal(t, "<3.0.0-0", out.Flags["power_led_blue"]["version_supported"]) + assert.NotContains(t, out.Flags["power_led_blue"], "values_version_supported") + + // invalid whole-flag constraints fail to load + _, err = targets.ReadTargetsDefFromBytes([]byte(`{ + "releases": { "v1.0.0": { "sha": "1" } }, + "flags": { "f": { "values": ["YES"], "version_supported": "not a constraint" } } + }`), "") + assert.NotNil(t, err) +} + +func TestInvalidFlagVersionSupported(t *testing.T) { + undefinedValue := `{ + "releases": { "v1.0.0": { "sha": "1" } }, + "tags": { "colorlcd": { "flags": { "language": { + "values": ["CN"], "values_version_supported": { "AR": ">= 3.0.0-0" } + }}}} + }` + _, err := targets.ReadTargetsDefFromBytes([]byte(undefinedValue), "") + assert.ErrorIs(t, err, targets.ErrInvalidValuesVersionSupported) + + badConstraint := `{ + "releases": { "v1.0.0": { "sha": "1" } }, + "flags": { "language": { + "values": ["AR"], "values_version_supported": { "AR": "not a constraint" } + }} + }` + _, err = targets.ReadTargetsDefFromBytes([]byte(badConstraint), "") + assert.NotNil(t, err) +} + +// loadShippedTargets loads the shipped targets.json. json.Unmarshal rather +// than ReadTargetsDefFromBytes: releases have no SHA in the file, they are +// resolved from the git repo at runtime. +func loadShippedTargets(t *testing.T) *targets.TargetsDef { + t.Helper() + data, err := os.ReadFile("../targets.json") + assert.Nil(t, err) + var defs targets.TargetsDef + assert.Nil(t, json.Unmarshal(data, &defs)) + + // older releases are still offered, so the limits tested are exercised + oldest, err := targets.NewVersionRef("v2.8.5") + assert.Nil(t, err) + assert.Contains(t, defs.Releases, *oldest) + return &defs +} + +func colorTarget(t *testing.T, defs *targets.TargetsDef) string { + t.Helper() + for name, target := range defs.Targets { + if slices.Contains(target.Tags, "colorlcd") { + return name + } + } + t.Fatal("no colorlcd target") + return "" +} + +// isAtLeast reports whether release ref is >= minVersion (nightly always is). +func isAtLeast(ref string, minVersion *semver.Version) bool { + v, err := semver.NewVersion(ref) + return ref == "nightly" || (err == nil && !v.LessThan(minVersion)) +} + +// Languages must only be offered from the release where they appear in +// EdgeTX's RADIO_LANGUAGES (radio/src/CMakeLists.txt). +func TestShippedTargetsLanguageReleases(t *testing.T) { + defs := loadShippedTargets(t) + color := colorTarget(t, defs) + + // language -> first EdgeTX release that has it + firstRelease := map[string]string{ + "HE": "2.9.0", + "RU": "2.10.0", + "UA": "2.10.0", + "KO": "2.11.0", + "AR": "3.0.0", + } + for lang, first := range firstRelease { + minVersion := semver.MustParse(first) + for k, r := range defs.Releases { + want := isAtLeast(k.String(), minVersion) + ok, _ := defs.IsOptionFlagSupportedByRelease(color, "language", lang, k.String()) + assert.Equal(t, want, ok, "%s @ %s", lang, k.String()) + assert.Equal(t, want, !slices.Contains(r.ExcludeFlags["language"], lang), + "exclude_flags %s @ %s", lang, k.String()) + } + } +} + +// Languages without B&W (stdlcd) fonts must only be offered to colour +// targets, e.g. KO only has LVGL fonts (EdgeTX/edgetx#6118). +func TestShippedTargetsColorOnlyLanguages(t *testing.T) { + defs := loadShippedTargets(t) + colorOnly := []string{"AR", "CN", "HE", "JP", "KO", "SK", "TW"} + for name, target := range defs.Targets { + isColor := slices.Contains(target.Tags, "colorlcd") + for _, lang := range colorOnly { + assert.Equal(t, isColor, defs.IsOptionFlagSupported(name, "language", lang), + "%s on %s", lang, name) + } + } +} + +// Whole flags that only exist in some EdgeTX releases. +func TestShippedTargetsFlagReleases(t *testing.T) { + defs := loadShippedTargets(t) + v3 := semver.MustParse("3.0.0-0") + tests := []struct { + flag, target string + values []string + supported func(ref string) bool + }{ + // POWER_LED_BLUE was removed in EdgeTX 3.0 + {"power_led_blue", "x9d", []string{"YES", "NO"}, + func(ref string) bool { return !isAtLeast(ref, v3) }}, + // KCX BT audio is main-only (EdgeTX/edgetx#6777, #7056), not in 2.12 + {"kcx_btaudio", "tx15", []string{"YES"}, + func(ref string) bool { return isAtLeast(ref, v3) }}, + } + for _, tt := range tests { + for k, r := range defs.Releases { + want := tt.supported(k.String()) + for _, value := range tt.values { + ok, _ := defs.IsOptionFlagSupportedByRelease(tt.target, tt.flag, value, k.String()) + assert.Equal(t, want, ok, "%s=%s @ %s", tt.flag, value, k.String()) + } + assert.Equal(t, want, len(r.ExcludeFlags[tt.flag]) == 0, + "exclude_flags %s @ %s", tt.flag, k.String()) + } + } +} +func ref(t *testing.T, s string) targets.VersionRef { + t.Helper() + r, err := targets.NewVersionRef(s) + assert.Nil(t, err) + return *r +} diff --git a/ui/src/components/jobs/JobCreateForm.tsx b/ui/src/components/jobs/JobCreateForm.tsx index 0be1857..ef280de 100644 --- a/ui/src/components/jobs/JobCreateForm.tsx +++ b/ui/src/components/jobs/JobCreateForm.tsx @@ -178,9 +178,21 @@ function JobCreateForm({ messageApi, onFinish }: Props) { flags[key].values = Array.from(valueSet.values()); } } + + // remove values not supported by the selected release + const excludeFlags = targets?.releases[currentRelease]?.exclude_flags ?? {}; + for (const [key, excluded] of Object.entries(excludeFlags)) { + if (!Object.hasOwn(flags, key)) continue; + const values = flags[key].values.filter((v) => !excluded.includes(v)); + if (values.length > 0) { + flags[key] = { ...flags[key], values }; + } else { + delete flags[key]; + } + } return flags; }, - [targets, currentTarget] + [targets, currentTarget, currentRelease] ); const [selectedFlags, setSelectedFlags] = useState([]); diff --git a/ui/src/hooks/useTargets.ts b/ui/src/hooks/useTargets.ts index eb55463..121795f 100644 --- a/ui/src/hooks/useTargets.ts +++ b/ui/src/hooks/useTargets.ts @@ -5,6 +5,8 @@ import { useQuery } from "@tanstack/react-query"; interface Release { sha: string; exclude_targets?: string[]; + // flag name -> values not supported by this release + exclude_flags?: Record; } interface Tag {