feat(observability-proxy): map application plurals to their kinds

Paths and RBAC name an application by its plural, while the lineage
labels that scope its logs and series carry the kind. The mapping comes
from ApplicationDefinitions, kept in one place so both application roots
scope by the same kind. A plural declared for two kinds is refused
rather than resolved by cache order.

Assisted-by: LLM
Signed-off-by: ZverGuy <maximbel2003@gmail.com>
This commit is contained in:
ZverGuy committed 2026-11-10 04:03:24 +07:00
1 parent b3288be903
commit ecb5de6051
2 files changed
+174

No files matched your search

+97
View File
@@ -0,0 +1,97 @@
/*
Copyright 2026 The Cozystack Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package observabilityproxy
import (
"errors"
"fmt"
"slices"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/tools/cache"
)
// ApplicationDefinitionsResource is where the plural of every application
// kind is declared (api/v1alpha1/applicationdefinitions_types.go).
var ApplicationDefinitionsResource = schema.GroupVersionResource{Group: "cozystack.io", Version: "v1alpha1", Resource: "applicationdefinitions"}
// ErrKindsNotSynced means the ApplicationDefinitions cache has not been
// filled yet, so an unknown plural cannot be told from a missing one.
var ErrKindsNotSynced = errors.New("application definitions not synced")
const pluralIndex = "plural"
// KindLookup maps an application plural, as it appears in paths and RBAC,
// to the kind the lineage labels carry. An unknown plural is "", nil.
type KindLookup interface {
Kind(plural string) (string, error)
}
// ApplicationPluralIndexers indexes ApplicationDefinitions by
// spec.application.plural; the informer feeding ApplicationKinds needs it.
func ApplicationPluralIndexers() cache.Indexers {
return cache.Indexers{pluralIndex: func(obj any) ([]string, error) {
u, ok := obj.(*unstructured.Unstructured)
if !ok {
return nil, nil
}
plural, _, _ := unstructured.NestedString(u.Object, "spec", "application", "plural")
if plural == "" {
return nil, nil
}
return []string{plural}, nil
}}
}
// ApplicationKinds is the one place the proxy maps a plural to its kind;
// both application roots use it.
type ApplicationKinds struct {
indexer cache.Indexer
hasSynced func() bool
}
func NewApplicationKinds(indexer cache.Indexer, hasSynced func() bool) *ApplicationKinds {
return &ApplicationKinds{indexer: indexer, hasSynced: hasSynced}
}
func (k *ApplicationKinds) Kind(plural string) (string, error) {
if !k.hasSynced() {
return "", ErrKindsNotSynced
}
objs, err := k.indexer.ByIndex(pluralIndex, plural)
if err != nil {
return "", err
}
var kinds []string
for _, obj := range objs {
kind, _, _ := unstructured.NestedString(obj.(*unstructured.Unstructured).Object, "spec", "application", "kind")
if kind != "" && !slices.Contains(kinds, kind) {
kinds = append(kinds, kind)
}
}
switch len(kinds) {
case 0:
return "", nil
case 1:
return kinds[0], nil
}
// Picking one would scope the request to whichever definition the
// cache happens to list first.
slices.Sort(kinds)
return "", fmt.Errorf("plural %q is declared for kinds %v", plural, kinds)
}
@@ -0,0 +1,77 @@
/*
Copyright 2026 The Cozystack Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package observabilityproxy
import (
"errors"
"testing"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/client-go/tools/cache"
)
func appDefinition(name, kind, plural string) *unstructured.Unstructured {
return &unstructured.Unstructured{Object: map[string]any{
"apiVersion": "cozystack.io/v1alpha1",
"kind": "ApplicationDefinition",
"metadata": map[string]any{"name": name},
"spec": map[string]any{"application": map[string]any{"kind": kind, "plural": plural, "singular": name}},
}}
}
func newTestKinds(t *testing.T, synced bool, defs ...*unstructured.Unstructured) *ApplicationKinds {
t.Helper()
indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, ApplicationPluralIndexers())
for _, d := range defs {
if err := indexer.Add(d); err != nil {
t.Fatal(err)
}
}
return NewApplicationKinds(indexer, func() bool { return synced })
}
func TestApplicationKinds(t *testing.T) {
kinds := newTestKinds(t, true,
appDefinition("postgres", "Postgres", "postgreses"),
appDefinition("vm-instance", "VMInstance", "vminstances"),
appDefinition("broken", "", "brokens"),
)
for plural, want := range map[string]string{"postgreses": "Postgres", "vminstances": "VMInstance", "postgres": "", "brokens": "", "": ""} {
got, err := kinds.Kind(plural)
if err != nil || got != want {
t.Errorf("Kind(%q) = %q, %v; want %q", plural, got, err, want)
}
}
}
func TestApplicationKindsNotSynced(t *testing.T) {
kinds := newTestKinds(t, false, appDefinition("postgres", "Postgres", "postgreses"))
if _, err := kinds.Kind("postgreses"); !errors.Is(err, ErrKindsNotSynced) {
t.Fatalf("Kind before sync: err = %v, want ErrKindsNotSynced", err)
}
}
func TestApplicationKindsAmbiguous(t *testing.T) {
kinds := newTestKinds(t, true, appDefinition("a", "Postgres", "postgreses"), appDefinition("b", "Postgresql", "postgreses"))
if kind, err := kinds.Kind("postgreses"); err == nil {
t.Fatalf("two kinds for one plural resolved to %q", kind)
}
same := newTestKinds(t, true, appDefinition("a", "Postgres", "postgreses"), appDefinition("b", "Postgres", "postgreses"))
if kind, err := same.Kind("postgreses"); err != nil || kind != "Postgres" {
t.Fatalf("duplicate definitions of one kind: %q, %v", kind, err)
}
}