pcm-coordinator/internal/scheduler/service/cloud/k8s.go

package cloud

import (
	"context"
	"fmt"
	"github.com/go-resty/resty/v2"
	"gitlink.org.cn/JointCloud/pcm-coordinator/internal/participant/cloud"
	"gitlink.org.cn/JointCloud/pcm-coordinator/internal/scheduler/service/collector"
	"gitlink.org.cn/JointCloud/pcm-coordinator/pkg/constants"
	"gitlink.org.cn/JointCloud/pcm-coordinator/pkg/repository/result"
	"gitlink.org.cn/JointCloud/pcm-coordinator/pkg/utils/restyclient"
	v1 "k8s.io/api/core/v1"
	v2 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// 定义枚举类型

type ParticipantCloud struct {
	participantId int64
	platform      string
	host          string
	userName      string
	accessToken   string
	*restyclient.RestyClient
}

func NewCloud(host string, id int64, platform string) *ParticipantCloud {
	return &ParticipantCloud{
		host:          host,
		participantId: id,
		platform:      platform,
		RestyClient:   restyclient.InitClient(host, ""),
	}
}

func (c *ParticipantCloud) GetContainer(ctx context.Context, taskId string, clusterId string) (*collector.Task, error) {
	reqUrl := c.host + cloud.GetContainer
	containerResp := &collector.ContainerDetailResp{}
	httpClient := resty.New().R()
	_, err := httpClient.SetHeaders(
		map[string]string{
			"Content-Type": "application/json",
			"traceId":      result.TraceIDFromContext(ctx),
		}).
		SetQueryParams(map[string]string{
			"pfId": clusterId,
			"name": taskId,
		}).
		SetResult(&containerResp).
		Get(reqUrl)
	if err != nil {
		return nil, err
	}
	fmt.Println("containerResp:", containerResp.Data)
	var resp collector.Task
	status := getStatusEnum(containerResp.Data)
	resp.Status = status
	// 提取 StartTime（Pod 启动时间）
	startTime := containerResp.Data.Status.StartTime
	if startTime == nil {
		fmt.Println("Pod 尚未启动，无 startTime")
	} else {
		resp.Start = startTime.Time.Format("2006-01-02 15:04:05")
	}

	// 提取 EndTime（容器终止时间，仅当 Pod 已结束时存在）
	// 遍历所有容器状态，查找已终止的容器
	var endTime *v2.Time
	for _, containerStatus := range containerResp.Data.Status.ContainerStatuses {
		if containerStatus.State.Terminated != nil {
			endTime = &containerStatus.State.Terminated.FinishedAt
			break // 取第一个终止的容器时间（若有多个容器，可根据需求调整）
		}
	}

	if endTime == nil {
		fmt.Println("Pod 尚未终止，无 endTime（可能仍在运行中）")
	} else {
		resp.End = endTime.Time.Format("2006-01-02 15:04:05")
	}

	return &resp, nil
}
func getStatusEnum(pod *v1.Pod) string {
	// 优先判断Pod的删除状态（是否正在删除）
	if !pod.DeletionTimestamp.IsZero() {
		// 已标记删除但未完全删除 → WaitDelete；已删除（若能查询到则表示未完全删除）
		return constants.WaitDelete
	}

	// 根据Pod的Phase（宏观状态）判断
	switch pod.Status.Phase {
	case v1.PodRunning:
		// 运行中：检查是否有容器在重启（可能处于WaitRestart）
		for _, cs := range pod.Status.ContainerStatuses {
			if cs.RestartCount > 0 && cs.State.Running == nil {
				// 有重启记录且当前运行中 → 刚重启完，对应WaitRestart
				return constants.WaitRestart
			}
		}
		return constants.Running

	case v1.PodPending:
		// Pending状态：检查容器是否在等待启动
		for _, cs := range pod.Status.ContainerStatuses {
			if cs.State.Waiting != nil {
				switch cs.State.Waiting.Reason {
				case "ContainerCreating", "PodInitializing":
					return constants.WaitStart // 等待启动
				case "Paused":
					return constants.WaitPause // 等待暂停（罕见，通常对应Pause状态）
				default:
					return constants.Waiting // 其他等待状态
				}
			}
		}
		return constants.Pending

	case v1.PodSucceeded:
		// 所有容器成功终止
		return constants.Succeeded

	case v1.PodFailed:
		// 至少一个容器失败终止
		return constants.Failed

	case v1.PodUnknown:
		// 未知状态 → 暂归为Waiting
		return constants.Waiting
	}

	// 检查容器状态（补充Phase未覆盖的情况）
	for _, cs := range pod.Status.ContainerStatuses {
		switch {
		case cs.State.Terminated != nil:
			if cs.State.Terminated.Reason == "Completed" {
				return constants.Completed // 容器正常完成
			}
			if cs.State.Terminated.Reason == "Error" {
				return constants.Failed // 错误终止
			}
			if cs.State.Terminated.Reason == "Cancelled" {
				return constants.Cancelled // 被取消
			}
		case cs.State.Waiting != nil && cs.State.Waiting.Reason == "Paused":
			return constants.WaitPause // 容器被暂停
		}
	}

	// 其他未覆盖状态（如部署中、已保存等）
	return constants.Deploying
}