mirror of
https://github.com/hanzoai/ai.git
synced 2026-11-21 02:36:49 +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.
229 lines
6.9 KiB
Go
229 lines
6.9 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"
|
|
"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/resource"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
metricsclientset "k8s.io/metrics/pkg/client/clientset/versioned"
|
|
)
|
|
|
|
func AddDetails(apps []*Application, lang string) {
|
|
if len(apps) == 0 {
|
|
return
|
|
}
|
|
if ensureK8sClient(lang) != nil {
|
|
return
|
|
}
|
|
var wg sync.WaitGroup
|
|
for _, app := range apps {
|
|
wg.Add(1)
|
|
go func(app *Application) {
|
|
defer wg.Done()
|
|
if details, err := GetApplicationView(app.Namespace, lang); err == nil {
|
|
app.Status = details.Status
|
|
app.Details = details
|
|
if app.URL == "" {
|
|
if url, err := GetURL(app.Namespace, lang); err == nil && url != "" {
|
|
app.URL = url
|
|
}
|
|
}
|
|
}
|
|
}(app)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
// GetURL retrieves the access URL for an application
|
|
func GetURL(namespace string, lang string) (string, error) {
|
|
nodeIPs := getNodeIPsFromCache()
|
|
services := getServicesFromCache(namespace, nodeIPs)
|
|
// Find first available access URL from services
|
|
for _, service := range services {
|
|
for _, port := range service.Ports {
|
|
if port.URL != "" {
|
|
return port.URL, nil
|
|
}
|
|
}
|
|
}
|
|
return "", fmt.Errorf("%s", i18n.Translate(lang, "object:no accessible URL found for application"))
|
|
}
|
|
|
|
// findIngressURL finds the external access URL for a service in Ingress rules.
|
|
func findIngressURL(serviceName string, servicePort int32, ingresses []*networkingv1.Ingress) string {
|
|
for _, ingress := range ingresses {
|
|
// Iterate through Ingress rules
|
|
for _, rule := range ingress.Spec.Rules {
|
|
if rule.HTTP == nil {
|
|
continue
|
|
}
|
|
// Build the hostname
|
|
host := rule.Host
|
|
if host == "" && len(ingress.Status.LoadBalancer.Ingress) > 0 {
|
|
// If the host is not specified in the rule, try to get it from the LoadBalancer status
|
|
lbIngress := ingress.Status.LoadBalancer.Ingress[0]
|
|
if lbIngress.Hostname != "" {
|
|
host = lbIngress.Hostname
|
|
} else if lbIngress.IP != "" {
|
|
host = lbIngress.IP
|
|
}
|
|
}
|
|
// Iterate through each path
|
|
for _, path := range rule.HTTP.Paths {
|
|
backend := path.Backend
|
|
if backend.Service != nil &&
|
|
backend.Service.Name == serviceName &&
|
|
backend.Service.Port.Number == servicePort {
|
|
scheme := "http"
|
|
if hasTLSForHost(ingress, host) {
|
|
scheme = "https"
|
|
}
|
|
pathStr := path.Path
|
|
if pathStr == "" {
|
|
pathStr = "/"
|
|
}
|
|
return scheme + "://" + host + pathStr
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// hasTLSForHost examine if the ingress has TLS configured for the given host
|
|
func hasTLSForHost(ingress *networkingv1.Ingress, host string) bool {
|
|
for _, tls := range ingress.Spec.TLS {
|
|
for _, tlsHost := range tls.Hosts {
|
|
if tlsHost == host {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// formatCPUUsage formats CPU usage quantity to human-readable format
|
|
func formatCPUUsage(quantity resource.Quantity) string {
|
|
milliValue := quantity.MilliValue()
|
|
if milliValue >= 1000 {
|
|
cores := float64(milliValue) / 1000
|
|
if cores == float64(int(cores)) {
|
|
return fmt.Sprintf("%d", int(cores))
|
|
}
|
|
return fmt.Sprintf("%.2f", cores)
|
|
}
|
|
// Display as milli-cores for < 1 core
|
|
return fmt.Sprintf("%dm", milliValue)
|
|
}
|
|
|
|
// formatMemoryUsage formats memory usage quantity to human-readable format
|
|
func formatMemoryUsage(quantity resource.Quantity) string {
|
|
bytes := quantity.Value()
|
|
switch {
|
|
case bytes >= 1<<30: // >= 1 GiB
|
|
gb := float64(bytes) / (1 << 30)
|
|
if gb >= 10 {
|
|
return fmt.Sprintf("%.0fGi", gb)
|
|
}
|
|
return fmt.Sprintf("%.1fGi", gb)
|
|
case bytes >= 1<<20: // >= 1 MiB
|
|
mb := float64(bytes) / (1 << 20)
|
|
if mb >= 10 {
|
|
return fmt.Sprintf("%.0fMi", mb)
|
|
}
|
|
return fmt.Sprintf("%.1fMi", mb)
|
|
case bytes >= 1<<10: // >= 1 KiB
|
|
return fmt.Sprintf("%.0fKi", float64(bytes)/(1<<10))
|
|
default:
|
|
return fmt.Sprintf("%d", bytes)
|
|
}
|
|
}
|
|
|
|
func calculateNamespaceMetrics(ctx context.Context, metricsClient *metricsclientset.Clientset, namespace string, deployCache map[string]map[string]*appsv1.Deployment, mu *sync.RWMutex, lang string) (*CachedMetrics, error) {
|
|
if metricsClient == nil {
|
|
return nil, fmt.Errorf("%s", i18n.Translate(lang, "object:metrics client not available"))
|
|
}
|
|
podMetricsList, err := metricsClient.MetricsV1beta1().PodMetricses(namespace).List(ctx, metav1.ListOptions{})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
totalCPU := resource.NewQuantity(0, resource.DecimalSI)
|
|
totalMemory := resource.NewQuantity(0, resource.BinarySI)
|
|
// Aggregate resource usage from all pods
|
|
for _, podMetrics := range podMetricsList.Items {
|
|
for _, container := range podMetrics.Containers {
|
|
if cpuUsage, ok := container.Usage[v1.ResourceCPU]; ok {
|
|
totalCPU.Add(cpuUsage)
|
|
}
|
|
if memUsage, ok := container.Usage[v1.ResourceMemory]; ok {
|
|
totalMemory.Add(memUsage)
|
|
}
|
|
}
|
|
}
|
|
var cpuPercentage, memPercentage float64
|
|
// Calculate percentages if deployment cache and mutex are provided
|
|
if deployCache != nil && mu != nil {
|
|
mu.RLock()
|
|
if deploys, exists := deployCache[namespace]; exists {
|
|
totalCPULimits := resource.NewQuantity(0, resource.DecimalSI)
|
|
totalMemoryLimits := resource.NewQuantity(0, resource.BinarySI)
|
|
for _, deploy := range deploys {
|
|
replicas := int32(1)
|
|
if deploy.Spec.Replicas != nil {
|
|
replicas = *deploy.Spec.Replicas
|
|
}
|
|
for _, container := range deploy.Spec.Template.Spec.Containers {
|
|
if container.Resources.Limits != nil {
|
|
if cpuLimit, ok := container.Resources.Limits[v1.ResourceCPU]; ok {
|
|
for i := int32(0); i < replicas; i++ {
|
|
totalCPULimits.Add(cpuLimit)
|
|
}
|
|
}
|
|
if memLimit, ok := container.Resources.Limits[v1.ResourceMemory]; ok {
|
|
for i := int32(0); i < replicas; i++ {
|
|
totalMemoryLimits.Add(memLimit)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if totalCPULimits.MilliValue() > 0 {
|
|
cpuPercentage = float64(totalCPU.MilliValue()) / float64(totalCPULimits.MilliValue()) * 100
|
|
}
|
|
if totalMemoryLimits.Value() > 0 {
|
|
memPercentage = float64(totalMemory.Value()) / float64(totalMemoryLimits.Value()) * 100
|
|
}
|
|
}
|
|
mu.RUnlock()
|
|
}
|
|
return &CachedMetrics{
|
|
TotalCPU: *totalCPU,
|
|
TotalMemory: *totalMemory,
|
|
PodCount: len(podMetricsList.Items),
|
|
CPUPercentage: cpuPercentage,
|
|
MemoryPercentage: memPercentage,
|
|
LastUpdated: time.Now(),
|
|
}, nil
|
|
}
|