0
0
package exposure
import (
"context"
"errors"
"fmt"
"strings"
"time"
"k8s.io/apimachinery/pkg/api/equality"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/rest"
exposurev1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/exposure/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/ingress"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/conds"
)
const (
ReasonIngressPending = "Pending"
ReasonIngressRegistered = "Registered"
ReasonIngressReplaced = "Replaced"
)
var subscriberReasons = map[exposurev1alpha1.IngressSubscriberState]string{
exposurev1alpha1.IngressSubscriberConnecting: "Connecting",
exposurev1alpha1.IngressSubscriberRegistered: ReasonIngressRegistered,
exposurev1alpha1.IngressSubscriberReconnecting: "Reconnecting",
exposurev1alpha1.IngressSubscriberWaiting: "Waiting",
exposurev1alpha1.IngressSubscriberReplaced: ReasonIngressReplaced,
exposurev1alpha1.IngressSubscriberClosed: "Closed",
}
func SubscriberStateOf(status ingress.SubscriberStatus) exposurev1alpha1.ExposureIngressSubscriber {
out := exposurev1alpha1.ExposureIngressSubscriber{
State: exposurev1alpha1.IngressSubscriberState(status.State),
LastError: status.LastError,
CloseCode: int32(status.CloseCode),
RelayVersion: status.RelayVersion,
}
if !status.RegisteredAt.IsZero() {
at := metav1.NewTime(status.RegisteredAt.UTC().Truncate(time.Second))
out.RegisteredAt = &at
}
return out
}
func IngressRegistered(sub *exposurev1alpha1.ExposureIngressSubscriber) (bool, string, string) {
if sub == nil || sub.State == "" {
return false, ReasonIngressPending, "no ingress subscriber has reported its state"
}
reason, ok := subscriberReasons[sub.State]
if !ok {
return false, ReasonIngressPending, fmt.Sprintf("the ingress subscriber reports an unknown state %q", sub.State)
}
if sub.State == exposurev1alpha1.IngressSubscriberRegistered {
message := "the ingress subscriber is registered at the relay"
if sub.RegisteredAt != nil {
message += " since " + sub.RegisteredAt.UTC().Format(time.RFC3339)
}
if sub.RelayVersion != "" {
message += " (relay " + sub.RelayVersion + ")"
}
return true, reason, message
}
if sub.State == exposurev1alpha1.IngressSubscriberReplaced {
return false, reason, "the ingress subscriber was replaced by a newer subscription of the same key and stopped; this exposure has no ingress until the process restarts"
}
message := "the ingress subscriber is " + string(sub.State)
if sub.CloseCode != 0 {
message += fmt.Sprintf(" after close code %d", sub.CloseCode)
}
if sub.LastError != "" {
message += ": " + sub.LastError
}
return false, reason, message
}
func SetIngressRegistered(conditions *[]metav1.Condition, generation int64, route *exposurev1alpha1.ExposureIngress,
sub *exposurev1alpha1.ExposureIngressSubscriber) {
if route == nil && sub == nil {
meta.RemoveStatusCondition(conditions, exposurev1alpha1.ConditionIngressRegistered)
return
}
ok, reason, message := IngressRegistered(sub)
conds.Set(conditions, generation, exposurev1alpha1.ConditionIngressRegistered, ok, reason, message)
}
func IngressRegisteredCurrent(obj *exposurev1alpha1.Exposure) bool {
var route *exposurev1alpha1.ExposureIngress
var sub *exposurev1alpha1.ExposureIngressSubscriber
if obj.Spec.Mode == exposurev1alpha1.ExposureModeIngress && obj.Status.Ingress != nil {
route, sub = obj.Status.Ingress, obj.Status.Ingress.Subscriber
if route.Host == "" && route.URL == "" {
route = nil
}
}
want := append([]metav1.Condition(nil), obj.Status.Conditions...)
SetIngressRegistered(&want, obj.Generation, route, sub)
have := meta.FindStatusCondition(obj.Status.Conditions, exposurev1alpha1.ConditionIngressRegistered)
next := meta.FindStatusCondition(want, exposurev1alpha1.ConditionIngressRegistered)
switch {
case have == nil || next == nil:
return have == nil && next == nil
default:
return have.Status == next.Status && have.Reason == next.Reason && have.Message == next.Message
}
}
func SubscriberStateEqual(a, b *exposurev1alpha1.ExposureIngressSubscriber) bool {
return equality.Semantic.DeepEqual(a, b)
}
const SubscriberStatusPath = "ingress.subscriber"
func SubscriberStatusFields(state exposurev1alpha1.ExposureIngressSubscriber) map[string]any {
subscriber := map[string]any{"state": string(state.State), "registeredAt": nil, "lastError": nil, "closeCode": nil, "relayVersion": nil}
if state.RegisteredAt != nil {
subscriber["registeredAt"] = state.RegisteredAt.UTC().Format(time.RFC3339)
}
if state.LastError != "" {
subscriber["lastError"] = state.LastError
}
if state.CloseCode != 0 {
subscriber["closeCode"] = int64(state.CloseCode)
}
if state.RelayVersion != "" {
subscriber["relayVersion"] = state.RelayVersion
}
return map[string]any{"ingress": map[string]any{"subscriber": subscriber}}
}
func ReportSubscriberState(ctx context.Context, kcp *rest.Config, workspace, exposureName string,
state exposurev1alpha1.ExposureIngressSubscriber) error {
workspace, exposureName = strings.TrimSpace(workspace), strings.TrimSpace(exposureName)
if workspace == "" || exposureName == "" {
return errors.New("exposure: reporting an ingress subscriber state needs a workspace and an Exposure name")
}
if _, ok := subscriberReasons[state.State]; !ok {
return fmt.Errorf("exposure: the ingress subscriber state %q is not one of connecting, registered, reconnecting, waiting, replaced, closed", state.State)
}
cl, err := kube.ForWorkspace(kcp, workspace)
if err != nil {
return err
}
doc := kube.Doc{"apiVersion": exposurev1alpha1.GroupVersion.String(), "kind": "Exposure", "metadata": map[string]any{"name": exposureName},
"status": SubscriberStatusFields(state)}
_, err = kube.Apply[exposurev1alpha1.Exposure](ctx, cl.Resource(exposurev1alpha1.ExposureGVR), doc,
kube.ApplyOptions{FieldManager: exposurev1alpha1.FieldManagerIngressSubscriber, Force: true, Status: true})
if err != nil {
return fmt.Errorf("exposure: reporting the ingress subscriber of %s in %s: %w", exposureName, workspace, err)
}
return nil
}