mirror of
https://github.com/hanzoai/ai.git
synced 2026-11-21 02:05:26 +00:00
Casibase's upstream '// Copyright <yr> The OpenAgent Authors. All Rights Reserved.' (and legacy 'The Casibase Authors' on older files) was stripped from every derived source file and replaced with a Hanzo-only line. This re-adds it as a '// Portions Copyright ...' line beneath the Hanzo line on the 573 casibase-derived files, using each file's real upstream year/holder. Net-new Hanzo files are untouched. Nothing deleted. LICENSE + NOTICE were already correct.
508 lines
17 KiB
Go
508 lines
17 KiB
Go
// Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.
|
|
// Portions Copyright 2025 The OpenAgent Authors. All Rights Reserved.
|
|
//
|
|
// 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 object
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/url"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/hanzoai/ai/i18n"
|
|
appsv1 "k8s.io/api/apps/v1"
|
|
v1 "k8s.io/api/core/v1"
|
|
networkingv1 "k8s.io/api/networking/v1"
|
|
"k8s.io/apimachinery/pkg/api/errors"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/client-go/tools/clientcmd"
|
|
metricsclientset "k8s.io/metrics/pkg/client/clientset/versioned"
|
|
)
|
|
|
|
type ApplicationView struct {
|
|
Services []ServiceDetail `json:"services"`
|
|
Credentials []EnvVariable `json:"credentials"`
|
|
Deployments []DeploymentDetail `json:"deployments"`
|
|
Events []ApplicationEvent `json:"events"`
|
|
Status string `json:"status"`
|
|
CreatedTime string `json:"createdTime"`
|
|
Namespace string `json:"namespace"`
|
|
Metrics *ResourceMetrics `json:"metrics,omitempty"`
|
|
}
|
|
|
|
// ResourceMetrics represents resource usage metrics
|
|
type ResourceMetrics struct {
|
|
CPUUsage string `json:"cpuUsage"` // CPU usage (e.g., "120m" for 120 millicores)
|
|
CPUPercentage float64 `json:"cpuPercentage"` // CPU usage percentage (0-100)
|
|
MemoryUsage string `json:"memoryUsage"` // Memory usage (e.g., "256Mi" for 256 mebibyte)
|
|
MemoryPercentage float64 `json:"memoryPercentage"` // Memory usage percentage (0-100)
|
|
PodCount int `json:"podCount"` // Number of active pods
|
|
}
|
|
type ServiceDetail struct {
|
|
Name string `json:"name"`
|
|
Type string `json:"type"`
|
|
ClusterIP string `json:"clusterIP"`
|
|
ExternalIP string `json:"externalIP"`
|
|
Ports []ServicePort `json:"ports"`
|
|
InternalHost string `json:"internalHost"`
|
|
ExternalHost string `json:"externalHost"`
|
|
CreatedTime string `json:"createdTime"`
|
|
}
|
|
type ServicePort struct {
|
|
Name string `json:"name"`
|
|
Port int32 `json:"port"`
|
|
NodePort int32 `json:"nodePort,omitempty"`
|
|
Protocol string `json:"protocol"`
|
|
URL string `json:"url,omitempty"`
|
|
}
|
|
type DeploymentDetail struct {
|
|
Name string `json:"name"`
|
|
Replicas int32 `json:"replicas"`
|
|
ReadyReplicas int32 `json:"readyReplicas"`
|
|
Containers []ContainerDetail `json:"containers"`
|
|
CreatedTime string `json:"createdTime"`
|
|
Status string `json:"status"`
|
|
}
|
|
type ContainerDetail struct {
|
|
Name string `json:"name"`
|
|
Image string `json:"image"`
|
|
Resources ResourceRequests `json:"resources"`
|
|
}
|
|
type ResourceRequests struct {
|
|
CPU string `json:"cpu"`
|
|
Memory string `json:"memory"`
|
|
}
|
|
type EnvVariable struct {
|
|
Name string `json:"name"`
|
|
Value string `json:"value"`
|
|
}
|
|
type ApplicationEvent struct {
|
|
Name string `json:"name"` // Event name
|
|
Type string `json:"type"` // Event type: Normal, Warning
|
|
Reason string `json:"reason"` // Event reason
|
|
Message string `json:"message"` // Event message
|
|
InvolvedObject string `json:"involvedObject"` // Related object
|
|
Source string `json:"source"` // Event source
|
|
Count int `json:"count"` // Event occurrence count
|
|
FirstTime string `json:"firstTime"` // First occurrence time
|
|
LastTime string `json:"lastTime"` // Last occurrence time
|
|
}
|
|
|
|
var (
|
|
metricsClient *metricsclientset.Clientset
|
|
metricsOnce sync.Once
|
|
)
|
|
|
|
// initMetricsClient init metrics client
|
|
func initMetricsClient(lang string) error {
|
|
if k8sClient == nil || k8sClient.config == nil {
|
|
return fmt.Errorf("%s", i18n.Translate(lang, "object:k8s client not initialized"))
|
|
}
|
|
var err error
|
|
metricsOnce.Do(func() {
|
|
metricsClient, err = metricsclientset.NewForConfig(k8sClient.config)
|
|
})
|
|
return err
|
|
}
|
|
|
|
// getNamespaceMetrics retrieves namespace metrics from cache with API fallback
|
|
func getNamespaceMetrics(namespace string, lang string) (*ResourceMetrics, error) {
|
|
if cacheManager != nil && cacheManager.started {
|
|
if cachedMetrics, found := cacheManager.getNamespaceMetricsFromCache(namespace); found {
|
|
if time.Since(cachedMetrics.LastUpdated) < 5*time.Minute {
|
|
return &ResourceMetrics{
|
|
CPUUsage: formatCPUUsage(cachedMetrics.TotalCPU),
|
|
CPUPercentage: cachedMetrics.CPUPercentage,
|
|
MemoryUsage: formatMemoryUsage(cachedMetrics.TotalMemory),
|
|
MemoryPercentage: cachedMetrics.MemoryPercentage,
|
|
PodCount: cachedMetrics.PodCount,
|
|
}, nil
|
|
}
|
|
}
|
|
}
|
|
if err := initMetricsClient(lang); err != nil {
|
|
return nil, err
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
|
|
defer cancel()
|
|
var metrics *CachedMetrics
|
|
var err error
|
|
if cacheManager != nil && cacheManager.started {
|
|
metrics, err = calculateNamespaceMetrics(ctx, metricsClient, namespace, cacheManager.deployCache, &cacheManager.mu, lang)
|
|
} else {
|
|
metrics, err = calculateNamespaceMetrics(ctx, metricsClient, namespace, nil, nil, lang)
|
|
}
|
|
if err != nil {
|
|
if errors.IsNotFound(err) || strings.Contains(err.Error(), "metrics.k8s.io") {
|
|
return nil, nil
|
|
}
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:failed to get pod metrics: %v"), err))
|
|
}
|
|
if metrics == nil {
|
|
return nil, nil
|
|
}
|
|
return &ResourceMetrics{
|
|
CPUUsage: formatCPUUsage(metrics.TotalCPU),
|
|
CPUPercentage: metrics.CPUPercentage,
|
|
MemoryUsage: formatMemoryUsage(metrics.TotalMemory),
|
|
MemoryPercentage: metrics.MemoryPercentage,
|
|
PodCount: metrics.PodCount,
|
|
}, nil
|
|
}
|
|
|
|
// getExternalHost attempts to get k8s server IP first, then falls back to provided host
|
|
func getExternalHost(fallbackHost string) string {
|
|
if cachedK8sHost != "" {
|
|
return cachedK8sHost
|
|
}
|
|
return fallbackHost
|
|
}
|
|
|
|
// parseK8sHost extracts server host from kubeconfig content
|
|
func parseK8sHost(configText string, lang string) (string, error) {
|
|
if strings.TrimSpace(configText) == "" {
|
|
return "", fmt.Errorf("%s", i18n.Translate(lang, "object:kubeconfig content is empty"))
|
|
}
|
|
config, err := clientcmd.RESTConfigFromKubeConfig([]byte(configText))
|
|
if err != nil {
|
|
return "", fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:failed to parse kubeconfig: %v"), err))
|
|
}
|
|
if config.Host == "" {
|
|
return "", fmt.Errorf("%s", i18n.Translate(lang, "object:server address not found"))
|
|
}
|
|
serverURL, err := url.Parse(config.Host)
|
|
if err != nil {
|
|
return "", fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:failed to parse server URL: %v"), err))
|
|
}
|
|
host := serverURL.Hostname()
|
|
if host == "" {
|
|
return "", fmt.Errorf("%s", i18n.Translate(lang, "object:unable to extract host"))
|
|
}
|
|
return host, nil
|
|
}
|
|
|
|
// GetApplicationView retrieves application view from cache with fallback
|
|
func GetApplicationView(namespace string, lang string) (*ApplicationView, error) {
|
|
if err := ensureK8sClient(lang); err != nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:failed to initialize k8s client: %v"), err))
|
|
}
|
|
if !k8sClient.connected {
|
|
return nil, fmt.Errorf("%s", i18n.Translate(lang, "object:k8s client not connected"))
|
|
}
|
|
// Try to get namespace from cache first
|
|
var ns *v1.Namespace
|
|
var nsFound bool
|
|
if cacheManager != nil && cacheManager.started {
|
|
ns = cacheManager.getNamespace(namespace)
|
|
nsFound = (ns != nil)
|
|
}
|
|
// Fallback to API call with timeout if not in cache
|
|
if !nsFound {
|
|
ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
|
|
defer cancel()
|
|
apiNs, err := k8sClient.clientSet.CoreV1().Namespaces().Get(ctx, namespace, metav1.GetOptions{})
|
|
if err != nil {
|
|
if errors.IsNotFound(err) {
|
|
return &ApplicationView{
|
|
Services: []ServiceDetail{},
|
|
Credentials: []EnvVariable{},
|
|
Deployments: []DeploymentDetail{},
|
|
Events: []ApplicationEvent{},
|
|
Status: StatusNotDeployed,
|
|
Namespace: namespace,
|
|
}, nil
|
|
}
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:failed to get namespace: %v"), err))
|
|
}
|
|
ns = apiNs
|
|
}
|
|
details := &ApplicationView{
|
|
Services: []ServiceDetail{},
|
|
Credentials: []EnvVariable{},
|
|
Deployments: []DeploymentDetail{},
|
|
Events: []ApplicationEvent{},
|
|
Status: StatusRunning,
|
|
CreatedTime: ns.CreationTimestamp.Format("2006-01-02 15:04:05"),
|
|
Namespace: namespace,
|
|
}
|
|
// Get data from cache with fallback to API
|
|
nodeIPs := getNodeIPsFromCache()
|
|
details.Services = getServicesFromCache(namespace, nodeIPs)
|
|
details.Deployments = getDeploymentsFromCache(namespace)
|
|
details.Credentials = getCredentialsFromCache(namespace)
|
|
details.Events = getEventsFromCache(namespace) // Added event retrieval
|
|
if metrics, err := getNamespaceMetrics(namespace, lang); err == nil && metrics != nil {
|
|
details.Metrics = metrics
|
|
}
|
|
return details, nil
|
|
}
|
|
|
|
// getNodeIPsFromCache retrieves node IPs from cache or fallback to API
|
|
func getNodeIPsFromCache() []string {
|
|
var nodes []*v1.Node
|
|
// Try cache first
|
|
if cacheManager != nil && cacheManager.started {
|
|
nodes = cacheManager.getNodes()
|
|
}
|
|
var nodeIPs []string
|
|
for _, node := range nodes {
|
|
// Try external IP first
|
|
for _, addr := range node.Status.Addresses {
|
|
if addr.Type == v1.NodeExternalIP && addr.Address != "" {
|
|
nodeIPs = append(nodeIPs, addr.Address)
|
|
break
|
|
}
|
|
}
|
|
// Fallback to internal IP if no external IP found
|
|
if len(nodeIPs) == 0 {
|
|
for _, addr := range node.Status.Addresses {
|
|
if addr.Type == v1.NodeInternalIP && addr.Address != "" {
|
|
nodeIPs = append(nodeIPs, addr.Address)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nodeIPs
|
|
}
|
|
|
|
// getServicesFromCache retrieves services from cache or fallback to API
|
|
func getServicesFromCache(namespace string, nodeIPs []string) []ServiceDetail {
|
|
var services []*v1.Service
|
|
// Try cache first
|
|
if cacheManager != nil && cacheManager.started {
|
|
services = cacheManager.getServices(namespace)
|
|
}
|
|
ingresses := getIngressFromCache(namespace)
|
|
var serviceDetails []ServiceDetail
|
|
for _, svc := range services {
|
|
detail := ServiceDetail{
|
|
Name: svc.Name,
|
|
Type: string(svc.Spec.Type),
|
|
ClusterIP: svc.Spec.ClusterIP,
|
|
Ports: []ServicePort{},
|
|
CreatedTime: svc.CreationTimestamp.Format("2006-01-02 15:04:05"),
|
|
InternalHost: fmt.Sprintf("%s.%s.svc.cluster.local", svc.Name, namespace),
|
|
}
|
|
// Determine external access based on service type
|
|
var host string
|
|
switch svc.Spec.Type {
|
|
case v1.ServiceTypeLoadBalancer:
|
|
if len(svc.Status.LoadBalancer.Ingress) > 0 {
|
|
ingress := svc.Status.LoadBalancer.Ingress[0]
|
|
if ingress.IP != "" {
|
|
detail.ExternalIP = ingress.IP
|
|
host = ingress.IP
|
|
} else if ingress.Hostname != "" {
|
|
host = ingress.Hostname
|
|
}
|
|
}
|
|
case v1.ServiceTypeNodePort:
|
|
if len(nodeIPs) > 0 {
|
|
host = nodeIPs[0]
|
|
}
|
|
case v1.ServiceTypeClusterIP:
|
|
host = getExternalHost("")
|
|
}
|
|
detail.ExternalHost = getExternalHost(host)
|
|
for _, port := range svc.Spec.Ports {
|
|
servicePort := ServicePort{
|
|
Name: port.Name,
|
|
Port: port.Port,
|
|
Protocol: string(port.Protocol),
|
|
}
|
|
// get URL from Ingress
|
|
ingressURL := findIngressURL(svc.Name, port.Port, ingresses)
|
|
if ingressURL != "" {
|
|
servicePort.URL = ingressURL
|
|
} else if port.NodePort != 0 {
|
|
servicePort.NodePort = port.NodePort
|
|
if detail.ExternalHost != "" {
|
|
servicePort.URL = fmt.Sprintf("%s:%d", detail.ExternalHost, port.NodePort)
|
|
}
|
|
}
|
|
detail.Ports = append(detail.Ports, servicePort)
|
|
}
|
|
serviceDetails = append(serviceDetails, detail)
|
|
}
|
|
return serviceDetails
|
|
}
|
|
|
|
func getIngressFromCache(namespace string) []*networkingv1.Ingress {
|
|
var ingresses []*networkingv1.Ingress
|
|
// First, try to get from the cache
|
|
if cacheManager != nil && cacheManager.started {
|
|
ingresses = cacheManager.getIngresses(namespace)
|
|
}
|
|
// If the cache is empty, try to fetch from the API
|
|
if len(ingresses) == 0 {
|
|
ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
|
|
defer cancel()
|
|
ingressList, err := k8sClient.clientSet.NetworkingV1().Ingresses(namespace).List(ctx, metav1.ListOptions{})
|
|
if err == nil {
|
|
for i := range ingressList.Items {
|
|
ingresses = append(ingresses, &ingressList.Items[i])
|
|
}
|
|
}
|
|
}
|
|
return ingresses
|
|
}
|
|
|
|
// getDeploymentsFromCache retrieves deployments from cache or fallback to API
|
|
func getDeploymentsFromCache(namespace string) []DeploymentDetail {
|
|
var deployments []*appsv1.Deployment
|
|
// Try cache first
|
|
if cacheManager != nil && cacheManager.started {
|
|
deployments = cacheManager.getDeployments(namespace)
|
|
}
|
|
var deploymentDetails []DeploymentDetail
|
|
for _, deployment := range deployments {
|
|
detail := DeploymentDetail{
|
|
Name: deployment.Name,
|
|
Replicas: *deployment.Spec.Replicas,
|
|
ReadyReplicas: deployment.Status.ReadyReplicas,
|
|
Containers: []ContainerDetail{},
|
|
CreatedTime: deployment.CreationTimestamp.Format("2006-01-02 15:04:05"),
|
|
}
|
|
// Determine deployment status
|
|
if detail.ReadyReplicas == detail.Replicas {
|
|
detail.Status = "Running"
|
|
} else if detail.ReadyReplicas > 0 {
|
|
detail.Status = "Partially Ready"
|
|
} else {
|
|
detail.Status = "Not Ready"
|
|
}
|
|
for _, container := range deployment.Spec.Template.Spec.Containers {
|
|
containerDetail := ContainerDetail{
|
|
Name: container.Name,
|
|
Image: container.Image,
|
|
}
|
|
if container.Resources.Requests != nil {
|
|
if cpuRequest := container.Resources.Requests[v1.ResourceCPU]; !cpuRequest.IsZero() {
|
|
containerDetail.Resources.CPU = cpuRequest.String()
|
|
}
|
|
if memoryRequest := container.Resources.Requests[v1.ResourceMemory]; !memoryRequest.IsZero() {
|
|
containerDetail.Resources.Memory = memoryRequest.String()
|
|
}
|
|
}
|
|
detail.Containers = append(detail.Containers, containerDetail)
|
|
}
|
|
deploymentDetails = append(deploymentDetails, detail)
|
|
}
|
|
return deploymentDetails
|
|
}
|
|
|
|
// getCredentialsFromCache extracts environment variables containing sensitive information
|
|
func getCredentialsFromCache(namespace string) []EnvVariable {
|
|
var deployments []*appsv1.Deployment
|
|
// Try cache first
|
|
if cacheManager != nil && cacheManager.started {
|
|
deployments = cacheManager.getDeployments(namespace)
|
|
}
|
|
credentialKeywords := []string{
|
|
"PASSWORD", "PASS", "SECRET", "KEY", "TOKEN", "AUTH",
|
|
"USER", "USERNAME", "LOGIN", "CREDENTIAL", "DATABASE_URL",
|
|
"DB_PASSWORD", "DB_USER", "ADMIN_PASSWORD", "ROOT_PASSWORD",
|
|
}
|
|
var credentials []EnvVariable
|
|
for _, deployment := range deployments {
|
|
for _, container := range deployment.Spec.Template.Spec.Containers {
|
|
for _, env := range container.Env {
|
|
envNameUpper := strings.ToUpper(env.Name)
|
|
isCredential := false
|
|
for _, keyword := range credentialKeywords {
|
|
if strings.Contains(envNameUpper, keyword) {
|
|
isCredential = true
|
|
break
|
|
}
|
|
}
|
|
if isCredential {
|
|
value := env.Value
|
|
if env.ValueFrom != nil {
|
|
if env.ValueFrom.SecretKeyRef != nil {
|
|
value = fmt.Sprintf("Secret: %s.%s", env.ValueFrom.SecretKeyRef.Name, env.ValueFrom.SecretKeyRef.Key)
|
|
} else if env.ValueFrom.ConfigMapKeyRef != nil {
|
|
value = fmt.Sprintf("ConfigMap: %s.%s", env.ValueFrom.ConfigMapKeyRef.Name, env.ValueFrom.ConfigMapKeyRef.Key)
|
|
}
|
|
}
|
|
credentials = append(credentials, EnvVariable{
|
|
Name: env.Name,
|
|
Value: value,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return credentials
|
|
}
|
|
|
|
// getEventsFromCache retrieves namespace-related events from cache or API
|
|
func getEventsFromCache(namespace string) []ApplicationEvent {
|
|
var events []*v1.Event
|
|
// Try cache first
|
|
if cacheManager != nil && cacheManager.started {
|
|
events = cacheManager.getEvents(namespace)
|
|
}
|
|
// If cache is empty, get from API
|
|
if len(events) == 0 {
|
|
ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
|
|
defer cancel()
|
|
eventList, err := k8sClient.clientSet.CoreV1().Events(namespace).List(ctx, metav1.ListOptions{})
|
|
if err == nil {
|
|
for i := range eventList.Items {
|
|
events = append(events, &eventList.Items[i])
|
|
}
|
|
}
|
|
}
|
|
return convertEventsToApplicationEvents(events)
|
|
}
|
|
|
|
// convertEventsToDetails converts Kubernetes Events to EventDetail
|
|
func convertEventsToApplicationEvents(events []*v1.Event) []ApplicationEvent {
|
|
eventDetails := make([]ApplicationEvent, 0)
|
|
for _, event := range events {
|
|
// Format involved object information
|
|
involvedObj := fmt.Sprintf("%s/%s",
|
|
strings.ToLower(event.InvolvedObject.Kind),
|
|
event.InvolvedObject.Name)
|
|
// Format event source information
|
|
source := event.Source.Component
|
|
if event.Source.Host != "" {
|
|
source = fmt.Sprintf("%s@%s", source, event.Source.Host)
|
|
}
|
|
detail := ApplicationEvent{
|
|
Name: event.Name,
|
|
Type: event.Type,
|
|
Reason: event.Reason,
|
|
Message: event.Message,
|
|
InvolvedObject: involvedObj,
|
|
Source: source,
|
|
Count: int(event.Count), // Convert int32 to int
|
|
FirstTime: event.FirstTimestamp.Format("2006-01-02 15:04:05"),
|
|
LastTime: event.LastTimestamp.Format("2006-01-02 15:04:05"),
|
|
}
|
|
eventDetails = append(eventDetails, detail)
|
|
}
|
|
sort.Slice(eventDetails, func(i, j int) bool {
|
|
return eventDetails[i].LastTime > eventDetails[j].LastTime
|
|
})
|
|
if len(eventDetails) > 50 {
|
|
eventDetails = eventDetails[:50]
|
|
}
|
|
return eventDetails
|
|
}
|