api/mesh/v1alpha1/dataplane_insight_helper.go

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 v1alpha1

import (
	"strings"
	"time"
)

import (
	"github.com/pkg/errors"
)

import (
	"github.com/apache/dubbo-kubernetes/api/generic"
	util_proto "github.com/apache/dubbo-kubernetes/pkg/util/proto"
)

var _ generic.Insight = &DataplaneInsight{}

func NewSubscriptionStatus(now time.Time) *DiscoverySubscriptionStatus {
	return &DiscoverySubscriptionStatus{
		LastUpdateTime: util_proto.MustTimestampProto(now),
		Total:          &DiscoveryServiceStats{},
		Cds:            &DiscoveryServiceStats{},
		Eds:            &DiscoveryServiceStats{},
		Lds:            &DiscoveryServiceStats{},
		Rds:            &DiscoveryServiceStats{},
	}
}

func NewVersion() *Version {
	return &Version{
		DubboDp: &DubboDpVersion{
			Version:   "",
			GitTag:    "",
			GitCommit: "",
			BuildDate: "",
		},
		Envoy: &EnvoyVersion{
			Version: "",
			Build:   "",
		},
		Dependencies: map[string]string{},
	}
}

func (x *DataplaneInsight) IsOnline() bool {
	for _, s := range x.GetSubscriptions() {
		if s.GetConnectTime() != nil && s.GetDisconnectTime() == nil {
			return true
		}
	}
	return false
}

func (x *DataplaneInsight) AllSubscriptions() []generic.Subscription {
	return generic.AllSubscriptions[*DiscoverySubscription](x)
}

func (x *DataplaneInsight) GetSubscription(id string) generic.Subscription {
	return generic.GetSubscription[*DiscoverySubscription](x, id)
}

func (x *DataplaneInsight) UpdateCert(generation time.Time, expiration time.Time, issuedBackend string, supportedBackends []string) error {
	if x.MTLS == nil {
		x.MTLS = &DataplaneInsight_MTLS{}
	}
	ts := util_proto.MustTimestampProto(expiration)
	if err := ts.CheckValid(); err != nil {
		return err
	}
	x.MTLS.CertificateExpirationTime = ts
	x.MTLS.CertificateRegenerations++
	ts = util_proto.MustTimestampProto(generation)
	if err := ts.CheckValid(); err != nil {
		return err
	}
	x.MTLS.IssuedBackend = issuedBackend
	x.MTLS.SupportedBackends = supportedBackends
	x.MTLS.LastCertificateRegeneration = ts
	return nil
}

func (x *DataplaneInsight) UpdateSubscription(s generic.Subscription) error {
	if x == nil {
		return nil
	}
	discoverySubscription, ok := s.(*DiscoverySubscription)
	if !ok {
		return errors.Errorf("invalid type %T for DataplaneInsight", s)
	}
	for i, sub := range x.GetSubscriptions() {
		if sub.GetId() == discoverySubscription.Id {
			x.Subscriptions[i] = discoverySubscription
			return nil
		}
	}
	x.finalizeSubscriptions()
	x.Subscriptions = append(x.Subscriptions, discoverySubscription)
	return nil
}

// If Dubbo CP was killed ungracefully then we can get a subscription without a DisconnectTime.
// Because of the way we process subscriptions the lack of DisconnectTime on old subscription
// will cause wrong status.
func (x *DataplaneInsight) finalizeSubscriptions() {
	now := util_proto.Now()
	for _, subscription := range x.GetSubscriptions() {
		if subscription.DisconnectTime == nil {
			subscription.DisconnectTime = now
		}
	}
}

func (x *DataplaneInsight) GetLastSubscription() generic.Subscription {
	if len(x.GetSubscriptions()) == 0 {
		return (*DiscoverySubscription)(nil)
	}
	return x.GetSubscriptions()[len(x.GetSubscriptions())-1]
}

func (x *DiscoverySubscription) SetDisconnectTime(t time.Time) {
	x.DisconnectTime = util_proto.MustTimestampProto(t)
}

func (x *DiscoverySubscription) IsOnline() bool {
	return x.GetConnectTime() != nil && x.GetDisconnectTime() == nil
}

func (x *DataplaneInsight) Sum(v func(*DiscoverySubscription) uint64) uint64 {
	var result uint64 = 0
	for _, s := range x.GetSubscriptions() {
		result += v(s)
	}
	return result
}

func (s *DiscoverySubscriptionStatus) StatsOf(typeUrl string) *DiscoveryServiceStats {
	if s == nil {
		return &DiscoveryServiceStats{}
	}
	// we rely on type URL suffix to get rid of the dependency on concrete V2 / V3 implementation
	switch {
	case strings.HasSuffix(typeUrl, "Cluster"):
		if s.Cds == nil {
			s.Cds = &DiscoveryServiceStats{}
		}
		return s.Cds
	case strings.HasSuffix(typeUrl, "ClusterLoadAssignment"):
		if s.Eds == nil {
			s.Eds = &DiscoveryServiceStats{}
		}
		return s.Eds
	case strings.HasSuffix(typeUrl, "Listener"):
		if s.Lds == nil {
			s.Lds = &DiscoveryServiceStats{}
		}
		return s.Lds
	case strings.HasSuffix(typeUrl, "RouteConfiguration"):
		if s.Rds == nil {
			s.Rds = &DiscoveryServiceStats{}
		}
		return s.Rds
	default:
		return &DiscoveryServiceStats{}
	}
}