pkg/admin/model/instance.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 model

import (
	gxset "github.com/dubbogo/gost/container/set"
)

import (
	"github.com/apache/dubbo-kubernetes/api/mesh/v1alpha1"
	mesh_proto "github.com/apache/dubbo-kubernetes/api/mesh/v1alpha1"
	"github.com/apache/dubbo-kubernetes/pkg/core/managers/apis/dataplane"
	"github.com/apache/dubbo-kubernetes/pkg/core/resources/apis/mesh"
	"github.com/apache/dubbo-kubernetes/pkg/core/resources/model"
)

type SearchInstanceReq struct {
	AppName  string `form:"appName"`
	Keywords string `form:"keywords"`
	PageReq
}

func NewSearchInstanceReq() *SearchInstanceReq {
	return &SearchInstanceReq{
		PageReq: PageReq{PageSize: 15},
	}
}

type InstanceDetailReq struct {
	InstanceName string `form:"instanceName"`
}

type SearchPaginationResult struct {
	List     any               `json:"list"`
	PageInfo *model.Pagination `json:"pageInfo"`
}

func NewSearchPaginationResult() *SearchPaginationResult {
	return &SearchPaginationResult{}
}

type SearchInstanceResp struct {
	Ip                  string            `json:"ip"`
	Name                string            `json:"name"`
	WorkloadName        string            `json:"workloadName"`
	AppName             string            `json:"appName"`
	DeployState         string            `json:"deployState"`
	DeployCluster       string            `json:"deployCluster"`
	RegisterState       string            `json:"registerState"`
	RegisterClustersSet *gxset.HashSet    `json:"-"`
	RegisterClusters    []string          `json:"registerClusters"`
	CreateTime          string            `json:"createTime"`
	RegisterTime        string            `json:"registerTime"` // TODO: not converted
	Labels              map[string]string `json:"labels"`
}

func NewSearchInstanceResp() *SearchInstanceResp {
	return &SearchInstanceResp{
		RegisterClustersSet: gxset.NewSet(),
		RegisterClusters:    make([]string, 0),
	}
}

func (r *SearchInstanceResp) FromDataplaneResource(dr *mesh.DataplaneResource) *SearchInstanceResp {
	// TODO: support more fields
	r.Ip = dr.GetIP()
	meta := dr.GetMeta()
	r.Name = meta.GetName()
	r.CreateTime = meta.GetCreationTime().String()
	r.RegisterTime = r.CreateTime // TODO: separate createTime and RegisterTime
	cluster := dr.Spec.Networking.Inbound[0].Tags[v1alpha1.ZoneTag]
	r.RegisterClustersSet.Add(cluster)
	for _, c := range r.RegisterClustersSet.Values() {
		r.RegisterClusters = append(r.RegisterClusters, c.(string))
	}
	r.DeployCluster = cluster
	if r.RegisterTime != "" {
		r.RegisterState = "Registed"
	} else {
		r.RegisterState = "UnRegisted"
	}
	// label conversion
	r.Labels = meta.GetLabels()
	// spec conversion
	spec := dr.Spec
	{
		statusValue := spec.Extensions[dataplane.ExtensionsPodPhaseKey]
		if v, ok := spec.Extensions[dataplane.ExtensionsPodStatusKey]; ok {
			statusValue = v
		}
		if v, ok := spec.Extensions[dataplane.ExtensionsContainerStatusReasonKey]; ok {
			statusValue = v
		}
		r.DeployState = statusValue
		r.WorkloadName = spec.Extensions[dataplane.ExtensionsWorkLoadKey]
		// name field source is different between universal and k8s mode
		r.AppName = spec.Extensions[mesh_proto.Application]
		if r.AppName == "" {
			for _, inbound := range spec.Networking.Inbound {
				r.AppName = inbound.Tags[v1alpha1.AppTag]
			}
		}
	}
	return r
}

type State struct {
	Label string `json:"label"`
	Level string `json:"level"`
	Tip   string `json:"tip"`
	Value string `json:"value"`
}

type InstanceDetailResp struct {
	RpcPort          int               `json:"rpcPort"`
	Ip               string            `json:"ip"`
	AppName          string            `json:"appName"`
	WorkloadName     string            `json:"workloadName"`
	Labels           map[string]string `json:"labels"`
	CreateTime       string            `json:"createTime"`
	ReadyTime        string            `json:"readyTime"`
	RegisterTime     string            `json:"registerTime"`
	RegisterClusters []string          `json:"registerClusters"`
	DeployCluster    string            `json:"deployCluster"`
	DeployState      string            `json:"deployState"`
	RegisterState    string            `json:"registerState"`
	Node             string            `json:"node"`
	Image            string            `json:"image"`
	Probes           ProbeStruct       `json:"probes"`
	Tags             map[string]string `json:"tags"`
}

type ProbeStruct struct {
	StartupProbe   StartupProbe   `json:"startupProbe"`
	ReadinessProbe ReadinessProbe `json:"readinessProbe"`
	LivenessProbe  LivenessProbe  `json:"livenessProbe"`
}

type StartupProbe struct {
	Type string `json:"type"`
	Port int    `json:"port"`
	Open bool   `json:"open"`
}
type ReadinessProbe struct {
	Type string `json:"type"`
	Port int    `json:"port"`
	Open bool   `json:"open"`
}
type LivenessProbe struct {
	Type string `json:"type"`
	Port int    `json:"port"`
	Open bool   `json:"open"`
}

func (r *InstanceDetailResp) FromInstanceDetail(id *InstanceDetail) *InstanceDetailResp {
	r.AppName = id.AppName
	r.RpcPort = id.RpcPort
	r.Ip = id.Ip
	r.WorkloadName = id.WorkloadName
	r.Labels = id.Labels
	r.CreateTime = id.CreateTime
	r.ReadyTime = id.ReadyTime
	r.RegisterTime = id.RegisterTime
	r.RegisterClusters = id.RegisterClusters.Values()
	r.DeployCluster = id.DeployCluster
	r.DeployCluster = id.DeployCluster
	r.DeployState = id.DeployState
	r.Node = id.Node
	r.Image = id.Image
	r.Tags = id.Tags
	r.RegisterState = id.RegisterState
	r.Probes = id.Probes
	return r
}

type InstanceDetail struct {
	RpcPort          int
	Ip               string
	AppName          string
	WorkloadName     string
	Labels           map[string]string
	CreateTime       string
	ReadyTime        string
	RegisterTime     string
	RegisterState    string
	RegisterClusters Set
	DeployCluster    string
	DeployState      string
	Node             string
	Image            string
	Tags             map[string]string
	Probes           ProbeStruct
}

func NewInstanceDetail() *InstanceDetail {
	return &InstanceDetail{
		RpcPort:          -1,
		Ip:               "",
		AppName:          "",
		WorkloadName:     "",
		Labels:           nil,
		CreateTime:       "",
		ReadyTime:        "",
		RegisterTime:     "",
		RegisterClusters: NewSet(),
		DeployCluster:    "",
		Node:             "",
		Image:            "",
	}
}

func (a *InstanceDetail) Merge(dataplane *mesh.DataplaneResource) {
	// TODO: support more fields
	inbounds := dataplane.Spec.Networking.Inbound
	for _, inbound := range inbounds {
		a.mergeInbound(inbound)
	}
	meta := dataplane.Meta
	a.mergeMeta(meta)
	extensions := dataplane.Spec.Extensions
	a.mergeExtensions(extensions)
	probes := dataplane.Spec.Probes
	a.mergeProbes(probes)

	a.Ip = dataplane.GetIP()
	if a.RegisterTime != "" {
		a.RegisterState = "Registed"
	} else {
		a.RegisterState = "UnRegisted"
	}
}

func (a *InstanceDetail) mergeInbound(inbound *v1alpha1.Dataplane_Networking_Inbound) {
	a.RpcPort = int(inbound.Port)
	a.RegisterClusters.Add(inbound.Tags[v1alpha1.ZoneTag])
	for _, deployCluster := range a.RegisterClusters.Values() {
		a.DeployCluster = deployCluster // TODO: separate deployCluster and registerCluster
	}
	a.Tags = inbound.Tags
	if a.AppName == "" {
		a.AppName = inbound.Tags[v1alpha1.AppTag]
	}
}

func (a *InstanceDetail) mergeExtensions(extensions map[string]string) {
	image := extensions[dataplane.ExtensionsImageKey]
	a.Image = image
	if a.AppName == "" {
		a.AppName = extensions[mesh_proto.Application]
	}
	a.WorkloadName = extensions[dataplane.ExtensionsWorkLoadKey]
	a.DeployState = extensions[dataplane.ExtensionsPodPhaseKey]
	a.Node = extensions[dataplane.ExtensionsNodeNameKey]
}

func (a *InstanceDetail) mergeMeta(meta model.ResourceMeta) {
	a.CreateTime = meta.GetCreationTime().String()
	a.RegisterTime = meta.GetModificationTime().String() // Not sure if it's the right field
	a.ReadyTime = a.RegisterTime
	// TODO: separate createTime , RegisterTime and ReadyTime
	a.Labels = meta.GetLabels()
}

func (a *InstanceDetail) mergeProbes(probes *mesh_proto.Dataplane_Probes) {
	if probes == nil {
		return
	}
	portStartup := probes.Endpoints[0].InboundPort
	portReadiness := probes.Endpoints[1].InboundPort
	portLiveness := probes.Endpoints[2].InboundPort
	a.Probes = ProbeStruct{
		StartupProbe: StartupProbe{
			Type: "HTTP", // TODO: support more scheme

			Port: int(portStartup),
			Open: true,
		},
		ReadinessProbe: ReadinessProbe{
			Type: "HTTP", // TODO: support more scheme
			Port: int(portReadiness),
			Open: true,
		},
		LivenessProbe: LivenessProbe{
			Type: "HTTP", // TODO: support more scheme
			Port: int(portLiveness),
			Open: true,
		},
	}
}