kubectl get apiservices.apiregistration.k8s.io

NAME                          SERVICE                    AVAILABLE   AGE
v1alpha1.apps.cozystack.io    cozy-system/cozystack-api  True        7h29m

/restart - 重啟虛擬機器
/console - 存取主控台
/vnc - VNC 連線管理

kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: default
  name: pod-and-pod-logs-reader
rules:
  - apiGroups: [""]
    resources: ["pods", "pods/log"]
    verbs: ["get", "list"]
  - apiGroups: [""]
    resources: ["pods/exec"]
    verbs: ["create"]

// 版本轉換範例
func ConvertV1ToV2(oldObj *v1.MyResource) (*v2.MyResource, error) {
    newObj := &v2.MyResource{}
    // 自定義轉換邏輯
    newObj.Spec.NewField = computeNewField(oldObj.Spec.OldField)
    return newObj, nil
}

func (s *APIServer) RegisterResource(gvr schema.GroupVersionResource) error {
    // 動態註冊資源類別
    s.resourceRegistry.Add(gvr)
    // 通知 Kubernetes 更新 API 發現資訊
    return s.updateAPIDiscovery()
}

apiVersion: platform.example.com/v1
kind: Postgres
metadata:
  name: my-database
spec:
  version: "13.4"
  storage: "100Gi"

# 使用者建立的自定義資源
apiVersion: platform.example.com/v1
kind: Redis
metadata:
  name: cache-service
spec:
  version: "6.2"

# 系統自動轉換成的 HelmRelease
apiVersion: helm.fluxcd.io/v1
kind: HelmRelease
metadata:
  name: cache-service
spec:
  chart:
    name: redis
    version: "6.2"

// 停用etcd支援的設定範例
options.Etcd = nil

// Application 定義了通用資源結構
type Application struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitempty"`
    AppVersion string `json:"appVersion,omitempty"`
    Spec   *apiextensionsv1.JSON `json:"spec,omitempty"`
    Status ApplicationStatus     `json:"status,omitempty"`
}

// ApplicationStatus 定義了應用程式的狀態
type ApplicationStatus struct {
    Version    string             `json:"version,omitempty"`
    Conditions []metav1.Condition `json:"conditions,omitempty"`
}

// ResourceConfig 代表設定檔的結構
type ResourceConfig struct {
    Resources []Resource `yaml:"resources"`
}

// Resource 描述個別資源設定
type Resource struct {
    Application ApplicationConfig `yaml:"application"`
    Release     ReleaseConfig     `yaml:"release"`
}

// ApplicationConfig 包含應用程式設定
type ApplicationConfig struct {
    Kind       string   `yaml:"kind"`
    Singular   string   `yaml:"singular"`
    Plural     string   `yaml:"plural"`
    ShortNames []string `yaml:"shortNames"`
}

data, err := os.ReadFile(path)
if err != nil {
    return nil, err
}

var config ResourceConfig
if err := yaml.Unmarshal(data, &config); err != nil {
    return nil, err
}

// 驗證設定檔內容
for i, res := range config.Resources {
    if res.Application.Kind == "" {
        return nil, fmt.Errorf("resource at index %d has an empty kind", i)
    }
    if res.Application.Plural == "" {
        return nil, fmt.Errorf("resource at index %d has an empty plural", i)
    }
    if res.Release.圖表.Name == "" {
        return nil, fmt.Errorf("resource at index %d has an empty chart name in release", i)
    }
    if res.Release.圖表.SourceRef.Kind == "" || 
       res.Release.圖表.SourceRef.Name == "" || 
       res.Release.圖表.SourceRef.Namespace == "" {
        return nil, fmt.Errorf("resource at index %d has an incomplete sourceRef for chart in release", i)
    }
}

return &config, nil

func RegisterDynamicTypes(scheme *runtime.Scheme, cfg *config.ResourceConfig) error {
    for _, res := range cfg.Resources {
        kind := res.Application.Kind
        gvk := SchemeGroupVersion.WithKind(kind)
        
        scheme.AddKnownTypeWithName(gvk, &Application{})
        scheme.AddKnownTypeWithName(
            gvk.GroupVersion().WithKind(kind+"List"), 
            &ApplicationList{})
            
        log.Printf("Registered kind: %s\n", kind)
    }
    return nil
}

resources:
  - application:
      kind: Bucket
      singular: bucket
      plural: buckets
    release:
      prefix: bucket-
      labels:
        cozystack.io/ui: "true"
      chart:
        name: bucket
        sourceRef:
          kind: HelmRepository
          name: cozystack-apps
          namespace: cozy-public

type REST struct {
    dynamicClient  dynamic.Interface
    gvr           schema.GroupVersionResource
    gvk           schema.GroupVersionKind
    kindName      string
    releaseConfig config.ReleaseConfig
}

var (
    _ rest.Getter          = &REST{}
    _ rest.Lister         = &REST{}
    _ rest.Updater        = &REST{}
    _ rest.Creater        = &REST{}
    _ rest.GracefulDeleter = &REST{}
    _ rest.Watcher        = &REST{}
    _ rest.Patcher        = &REST{}
)

func NewREST(dynamicClient dynamic.Interface, config *config.Resource) *REST {
    return &REST{
        dynamicClient: dynamicClient,
        gvr: schema.GroupVersionResource{
            Group:    appsv1alpha1.GroupName,
            Version:  "v1alpha1",
            Resource: config.Application.Plural,
        },
        gvk: schema.GroupVersion{
            Group:   appsv1alpha1.GroupName,
            Version: "v1alpha1",
        }.WithKind(config.Application.Kind),
        kindName:      config.Application.Kind,
        releaseConfig: config.Release,
    }
}

func (r *REST) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) {
    app, ok := obj.(*appsv1alpha1.Application)
    if !ok {
        return nil, fmt.Errorf("expected Application object, got %T", obj)
    }
    
    helmRelease, err := r.ConvertApplicationToHelmRelease(app)
    if err != nil {
        klog.Errorf("Conversion error: %v", err)
        return nil, fmt.Errorf("conversion error: %v", err)
    }
    
    helmRelease.Labels = mergeMaps(r.releaseConfig.Labels, helmRelease.Labels)
    helmRelease.Labels = mergeMaps(helmRelease.Labels, addPrefixedMap(app.Labels, LabelPrefix))
}

func (r *REST) NamespaceScoped() bool {
    return true
}

func (r *REST) GetSingularName() string {
    return r.gvr.Resource
}

func (r *REST) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) {
    app := obj.(*customresource.Application)
    
    // 建立 HelmRelease 物件
    helmRelease := &helmv2beta1.HelmRelease{
        ObjectMeta: metav1.ObjectMeta{
            Name:      r.releaseConfig.Prefix + app.Name,
            Namespace: app.Namespace,
        },
    }
    
    // 轉換為非結構化格式
    unstructuredHR, err := runtime.DefaultUnstructuredConverter.ToUnstructured(helmRelease)
    if err != nil {
        return nil, fmt.Errorf("failed to convert HelmRelease to unstructured: %v", err)
    }
    
    // 在 Kubernetes 中建立 HelmRelease
    createdHR, err := r.dynamicClient.Resource(helmReleaseGVR).
        Namespace(app.Namespace).
        Create(ctx, &unstructured.Unstructured{Object: unstructuredHR}, *options)
}

func (r *REST) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
    namespace, err := r.getNamespace(ctx)
    if err != nil {
        klog.Errorf("Failed to get namespace: %v", err)
        return nil, err
    }
    
    // 使用字首取得 HelmRelease
    helmReleaseName := r.releaseConfig.Prefix + name
    hr, err := r.dynamicClient.Resource(helmReleaseGVR).
        Namespace(namespace).
        Get(ctx, helmReleaseName, *options)
        
    // 檢查是否符合篩選條件
    if !r.shouldIncludeHelmRelease(hr) {
        return nil, apierrors.NewNotFound(r.gvr.GroupResource(), name)
    }
    
    // 轉換為 Application
    convertedApp, err := r.ConvertHelmReleaseToApplication(hr)
    if err != nil {
        return nil, fmt.Errorf("conversion error: %v", err)
    }
}

// List 方法負責處理 Application 資源的列表查詢
// 它將查詢條件對映到 HelmRelease 資源,並轉換結果
func (r *REST) List(ctx context.Context, options *metainternalversion.ListOptions) (runtime.Object, error) {
    // 檢查 namespace 
    namespace := genericapirequest.NamespaceValue(ctx)
    if namespace == "" {
        return nil, fmt.Errorf("namespace is required")
    }

    // 記錄除錯資訊
    klog.V(6).Infof("正在嘗試列出 %s 名稱空間中的 HelmRelease，選項為: %v", namespace, options)

    // 從請求中取得資源名稱(如果有的話)
    var resourceName string 
    if requestInfo, ok := request.RequestInfoFrom(ctx); ok {
        resourceName = requestInfo.Name
    }

    // 初始化選擇器對映變數
    var helmFieldSelector string
    var helmLabelSelector string

    // 處理欄位選擇器
    if options.FieldSelector != nil {
        fs, err := fields.ParseSelector(options.FieldSelector.String())
        if err != nil {
            klog.Errorf("無效的欄位選擇器: %v", err)
            return nil, fmt.Errorf("無效的欄位選擇器: %v", err)  
        }

        // 檢查選擇器是否針對 metadata.name
        if name, exists := fs.RequiresExactMatch("metadata.name"); exists {
            // 將 Application 名稱轉換為 HelmRelease 名稱
            mappedName := r.releaseConfig.Prefix + name
            helmFieldSelector = fields.OneTermEqualSelector("metadata.name", mappedName).String()
        } else {
            // 如果欄位選擇器包含其他欄位,直接對映
            helmFieldSelector = fs.String()
        }
    }

    // 處理標籤選擇器
    if options.LabelSelector != nil {
        ls := options.LabelSelector.String()
        parsedLabels, err := labels.Parse(ls)
        if err != nil {
            klog.Errorf("無效的標籤選擇器: %v", err)
            return nil, fmt.Errorf("無效的標籤選擇器: %v", err)
        }

        if !parsedLabels.Empty() {
            reqs, _ := parsedLabels.Requirements()
            var prefixedReqs []labels.Requirement

            // 為每個標籤鍵新增字首
            for _, req := range reqs {
                prefixedReq, err := labels.NewRequirement(
                    LabelPrefix+req.Key(),
                    req.Operator(),
                    req.Values().List(),
                )
                if err != nil {
                    klog.Errorf("標籤鍵新增字首時發生錯誤: %v", err)
                    return nil, fmt.Errorf("標籤鍵新增字首時發生錯誤: %v", err)
                }
                prefixedReqs = append(prefixedReqs, *prefixedReq)
            }
            helmLabelSelector = labels.NewSelector().Add(prefixedReqs...).String()
        }
    }

    // 使用對映後的選擇器設定 ListOptions
    metaOptions := metav1.ListOptions{
        FieldSelector: helmFieldSelector,
        LabelSelector: helmLabelSelector,
    }

    // 使用對映的選擇器列出 HelmReleases
    hrList, err := r.dynamicClient.Resource(helmReleaseGVR).
        Namespace(namespace).List(ctx, metaOptions)
    if err != nil {
        klog.Errorf("列出 HelmReleases 時發生錯誤: %v", err)
        return nil, err
    }

    // 初始化空的 Application 列表
    appList := &appsv1alpha1.ApplicationList{
        TypeMeta: metav1.TypeMeta{
            APIVersion: "apps.cozystack.io/v1alpha1",
            Kind:       "ApplicationList",
        },
        ListMeta: metav1.ListMeta{
            ResourceVersion: hrList.GetResourceVersion(),
        },
        Items: []appsv1alpha1.Application{},
    }

    // 遍歷 HelmReleases 並轉換為 Applications
    for _, hr := range hrList.Items {
        if !r.shouldIncludeHelmRelease(&hr) {
            continue
        }

        app, err := r.ConvertHelmReleaseToApplication(&hr)
        if err != nil {
            klog.Errorf("將 HelmRelease %s 轉換為 Application 時發生錯誤: %v",
                hr.GetName(), err)
            continue
        }

        // 如果設定了資源名稱,檢查是否比對
        if resourceName != "" && app.Name != resourceName {
            continue
        }

        // 套用標籤選擇器
        if options.LabelSelector != nil {
            sel, err := labels.Parse(options.LabelSelector.String())
            if err != nil {
                klog.Errorf("無效的標籤選擇器: %v", err)
                continue
            }
            if !sel.Matches(labels.Set(app.Labels)) {
                continue
            }
        }

        // 套用欄位選擇器
        if options.FieldSelector != nil {
            fs, err := fields.ParseSelector(options.FieldSelector.String()) 
            if err != nil {
                klog.Errorf("無效的欄位選擇器: %v", err)
                continue
            }

            fieldsSet := fields.Set{
                "metadata.name":      app.Name,
                "metadata.namespace": app.Namespace,
            }
            if !fs.Matches(fieldsSet) {
                continue
            }
        }

        appList.Items = append(appList.Items, app)
    }

    klog.V(6).Infof("成功列出 %s 名稱空間中的 %d 個 Application 資源",
        namespace, len(appList.Items))
    return appList, nil
}

func (r *ResourceConverter) Update(ctx context.Context, name string, objInfo Object, createValidation, updateValidation UpdateFunc) (runtime.Object, bool, error) {
    // 取得既有的 Application 物件
    oldObj, err := r.Get(ctx, name, &metav1.GetOptions{})
    if err != nil {
        if apierrors.IsNotFound(err) && createValidation != nil {
            // 若物件不存在與允許建立，則建立新物件
            obj, err := objInfo.UpdatedObject(ctx, nil)
            if err != nil {
                klog.Errorf("Failed to get updated object: %v", err)
                return nil, false, err
            }
            
            createdObj, err := r.Create(ctx, obj, createValidation, &metav1.CreateOptions{})
            if err != nil {
                klog.Errorf("Failed to create new Application: %v", err)
                return nil, false, err
            }
            return createdObj, true, nil
        }
        return nil, false, err
    }
    
    // 更新 Application 物件
    newObj, err := objInfo.UpdatedObject(ctx, oldObj)
    if err != nil {
        klog.Errorf("Failed to get updated object: %v", err)
        return nil, false, err
    }
    
    // 執行更新驗證
    if updateValidation != nil {
        if err := updateValidation(ctx, newObj, oldObj); err != nil {
            klog.Errorf("Update validation failed: %v", err)
            return nil, false, err
        }
    }
    
    return newObj, true, nil
}

func (r *ResourceConverter) ConvertApplicationToHelmRelease(app *appsv1alpha1.Application) (*helmRelease, error) {
    helmRelease, err := r.convertToHelmRelease(app)
    if err != nil {
        return nil, err
    }
    
    // 合併系統標籤
    helmRelease.Labels = mergeMaps(r.releaseConfig.Labels, helmRelease.Labels)
    
    // 合併使用者標籤（帶字首）
    helmRelease.Labels = mergeMaps(
        helmRelease.Labels,
        addPrefixedMap(app.Labels, LabelPrefix)
    )
    
    return helmRelease, nil
}

func (r *ResourceConverter) handleUnstructuredData(helmRelease *helmRelease) (*unstructured.Unstructured, error) {
    unstructuredHR, err := runtime.DefaultUnstructuredConverter.ToUnstructured(helmRelease)
    if err != nil {
        return nil, fmt.Errorf("failed to convert to unstructured: %v", err)
    }
    
    metadata, found, err := unstructured.NestedMap(unstructuredHR, "metadata")
    if err != nil || !found {
        return nil, fmt.Errorf("failed to retrieve metadata: %v", err)
    }
    
    return &unstructured.Unstructured{Object: unstructuredHR}, nil
}

func (r *ResourceConverter) shouldIncludeHelmRelease(obj *unstructured.Unstructured) bool {
    // 驗證 chart 名稱和來源參考
    chartName, found, err := unstructured.NestedString(obj.Object, "spec", "chart", "name")
    if err != nil || !found {
        return false
    }
    
    sourceRef, found, err := unstructured.NestedMap(obj.Object, "spec", "chart", "sourceRef")
    if err != nil || !found {
        return false
    }
    
    return chartName != "" && sourceRef != nil
}

// Delete 處理 Application 資源的刪除
func (r *REST) Delete(ctx context.Context, name string, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions) (runtime.Object, bool, error) {
    namespace, err := r.getNamespace(ctx)
    if err != nil {
        klog.Errorf("Failed to get namespace: %v", err)
        return nil, false, err
    }
    
    // 建構 HelmRelease 名稱
    helmReleaseName := r.releaseConfig.Prefix + name
    
    // 先取得 HelmRelease 檢查是否存在
    hr, err := r.dynamicClient.Resource(helmReleaseGVR).
        Namespace(namespace).
        Get(ctx, helmReleaseName, metav1.GetOptions{})
    
    // 錯誤處理邏輯
    if err != nil {
        if apierrors.IsNotFound(err) {
            return nil, false, apierrors.NewNotFound(r.gvr.GroupResource(), name)
        }
        return nil, false, err
    }
    
    // 刪除對應的 HelmRelease
    err = r.dynamicClient.Resource(helmReleaseGVR).
        Namespace(namespace).
        Delete(ctx, helmReleaseName, *options)
        
    if err != nil {
        return nil, false, fmt.Errorf("failed to delete HelmRelease: %v", err)
    }
    
    return nil, true, nil
}

// Watch 設定 HelmRelease 的監控並轉換事件
func (r *REST) Watch(ctx context.Context, options *metainternalversion.ListOptions) (watch.Interface, error) {
    namespace, err := r.getNamespace(ctx)
    if err != nil {
        klog.Errorf("Failed to get namespace: %v", err)
        return nil, err
    }
    
    var helmFieldSelector string
    var helmLabelSelector string
    
    // 處理欄位選擇器
    if options.FieldSelector != nil {
        fs, err := fields.ParseSelector(options.FieldSelector.String())
        if err != nil {
            return nil, fmt.Errorf("invalid field selector: %v", err)
        }
        
        // 處理 metadata.name 的對映
        if name, exists := fs.RequiresExactMatch("metadata.name"); exists {
            mappedName := r.releaseConfig.Prefix + name
            helmFieldSelector = fields.OneTermEqualSelector("metadata.name", mappedName).String()
        } else {
            helmFieldSelector = fs.String()
        }
    }

// ConvertHelmReleaseToApplication 將 HelmRelease 資源轉換為 Application 物件
func (r *REST) ConvertHelmReleaseToApplication(hr *unstructured.Unstructured) (*appv1.Application, error) {
    // 取得 HelmRelease 的基本資訊
    name := hr.GetName()
    namespace := hr.GetNamespace()
    labels := hr.GetLabels()
    annotations := hr.GetAnnotations()

    // 從 HelmRelease 規格中提取 chart 資訊
    spec, found, err := unstructured.NestedMap(hr.Object, "spec")
    if err != nil || !found {
        return nil, fmt.Errorf("無法取得 HelmRelease 規格: %v", err)
    }

    // 建立 Application 物件
    app := &appv1.Application{
        ObjectMeta: metav1.ObjectMeta{
            Name:        name,
            Namespace:   namespace,
            Labels:      labels,
            Annotations: annotations,
        },
        Spec: appv1.ApplicationSpec{
            // 設定應用程式來源
            Source: appv1.ApplicationSource{
                RepoURL:        getStringFromMap(spec, "chart", "repository"),
                Path:           getStringFromMap(spec, "chart", "name"),
                TargetRevision: getStringFromMap(spec, "chart", "version"),
                Helm: &appv1.ApplicationSourceHelm{
                    // 提取 Helm 相關設定
                    ValueFiles: extractValueFiles(spec),
                    Values:     extractHelmValues(spec),
                },
            },
            // 設定目標佈署環境
            Destination: appv1.ApplicationDestination{
                Server:    "https://kubernetes.default.svc",
                Namespace: namespace,
            },
        },
    }

    // 處理同步策略
    app.Spec.SyncPolicy = &appv1.SyncPolicy{
        Automated: &appv1.SyncPolicyAutomated{
            Prune:    true,
            SelfHeal: true,
        },
    }

    return app, nil
}

// 從對映中安全地取得字串值
func getStringFromMap(m map[string]interface{}, keys ...string) string {
    current := m
    for i, key := range keys {
        if i == len(keys)-1 {
            if val, ok := current[key].(string); ok {
                return val
            }
            return ""
        }
        if next, ok := current[key].(map[string]interface{}); ok {
            current = next
        } else {
            return ""
        }
    }
    return ""
}

// 提取 Helm valueFiles 設定
func extractValueFiles(spec map[string]interface{}) []string {
    var valueFiles []string
    if values, ok := spec["valueFiles"].([]interface{}); ok {
        for _, v := range values {
            if strVal, ok := v.(string); ok {
                valueFiles = append(valueFiles, strVal)
            }
        }
    }
    return valueFiles
}

// 提取 Helm values 設定
func extractHelmValues(spec map[string]interface{}) string {
    if values, ok := spec["values"].(map[string]interface{}); ok {
        // 將 values 轉換為 YAML 格式
        yamlData, err := yaml.Marshal(values)
        if err != nil {
            klog.Errorf("無法序列化 Helm values: %v", err)
            return ""
        }
        return string(yamlData)
    }
    return ""
}

// 解析HelmRelease並檢查是否符合圖表(圖表)規格
func (r *REST) matches圖表Name(hr *unstructured.Unstructured) bool {
    // 從 HelmRelease 物件中取得圖表名稱
    chartName, found, err := unstructured.NestedString(hr.Object, "spec", "chart", "spec", "chart")
    // 若發生錯誤或找不到圖表名稱欄位,則記錄訊息並回傳 false
    if err != nil || !found {
        klog.V(6).Infof("HelmRelease %s 缺少 spec.chart.spec.chart 欄位: %v",
            hr.GetName(), err)
        return false
    }
    
    // 比對圖表名稱是否符合預期
    if chartName != r.releaseConfig.圖表.Name {
        klog.V(6).Infof("HelmRelease %s 的圖表名稱 %s 與預期的 %s 不符",
            hr.GetName(), chartName, r.releaseConfig.圖表.Name)
        return false 
    }

    // 進一步檢查 SourceRef 設定與字首是否符合
    return r.matchesSourceRefAndPrefix(hr)
}

// 檢查 SourceRef 與字首是否符合要求
func (r *REST) matchesSourceRefAndPrefix(hr *unstructured.Unstructured) bool {
    // 取得 SourceRef 相關欄位
    sourceRefKind, found, err := unstructured.NestedString(hr.Object, "spec", "chart", "spec", "sourceRef", "kind")
    if err != nil || !found {
        klog.V(6).Infof("HelmRelease %s 缺少 spec.chart.spec.sourceRef.kind 欄位: %v",
            hr.GetName(), err)
        return false
    }

    sourceRefName, found, err := unstructured.NestedString(hr.Object, "spec", "chart", "spec", "sourceRef", "name") 
    if err != nil || !found {
        klog.V(6).Infof("HelmRelease %s 缺少 spec.chart.spec.sourceRef.name 欄位: %v",
            hr.GetName(), err)
        return false
    }

    sourceRefNamespace, found, err := unstructured.NestedString(hr.Object, "spec", "chart", "spec", "sourceRef", "namespace")
    if err != nil || !found {
        klog.V(6).Infof("HelmRelease %s 缺少 spec.chart.spec.sourceRef.namespace 欄位: %v",
            hr.GetName(), err)
        return false
    }

    // 檢查 SourceRef 是否符合設定要求
    if sourceRefKind != r.releaseConfig.圖表.SourceRef.Kind ||
        sourceRefName != r.releaseConfig.圖表.SourceRef.Name ||
        sourceRefNamespace != r.releaseConfig.圖表.SourceRef.Namespace {
        klog.V(6).Infof("HelmRelease %s 的 sourceRef 與預期值不符",
            hr.GetName())
        return false
    }

    // 檢查名稱字首是否符合要求
    name := hr.GetName()
    if !strings.HasPrefix(name, r.releaseConfig.Prefix) {
        klog.V(6).Infof("HelmRelease %s 不具備預期的字首 %s",
            name, r.releaseConfig.Prefix)
        return false
    }

    return true
}

// 從連貫的背景與環境中取得名稱空間
func (r *REST) getNamespace(ctx context.Context) (string, error) {
    namespace, ok := request.NamespaceFrom(ctx)
    if !ok {
        err := fmt.Errorf("在連貫的背景與環境中找不到名稱空間")
        klog.Errorf(err.Error())
        return "", err
    }
    return namespace, nil
}

// 建立標籤選擇器
func buildLabelSelector(labels map[string]string) string {
    var selectors []string
    for k, v := range labels {
        selectors = append(selectors, fmt.Sprintf("%s=%s", k, v))
    }
    return strings.Join(selectors, ",")
}

// 合併兩個 map
func mergeMaps(a, b map[string]string) map[string]string {
    if a == nil && b == nil {
        return nil
    }
    if a == nil {
        return b
    }
    if b == nil {
        return a
    }
    
    merged := make(map[string]string, len(a)+len(b))
    for k, v := range a {
        merged[k] = v
    }
    for k, v := range b {
        merged[k] = v
    }
    return merged
}

// 為 map 的 key 增加字首
func addPrefixedMap(original map[string]string, prefix string) map[string]string {
    if original == nil {
        return nil
    }
    processed := make(map[string]string, len(original))
    for k, v := range original {
        processed[prefix+k] = v
    }
    return processed
}

// 過濾具有特定字首的 map 專案
func filterPrefixedMap(original map[string]string, prefix string) map[string]string {
    if original == nil {
        return nil
    }
    processed := make(map[string]string)
    for k, v := range original {
        if strings.HasPrefix(k, prefix) {
            newKey := strings.TrimPrefix(k, prefix)
            processed[newKey] = v
        }
    }
    return processed
}

// 將 HelmRelease 轉換為 Application
func (r *REST) ConvertHelmReleaseToApplication(hr *unstructured.Unstructured) (appsv1alpha1.Application, error) {
    klog.V(6).Infof("正在將 HelmRelease %s 轉換為 Application", hr.GetName())
    
    var helmRelease helmv2.HelmRelease
    // 將非結構化物件轉換為 HelmRelease 結構
    err := runtime.DefaultUnstructuredConverter.FromUnstructured(hr.Object, &helmRelease)
    if err != nil {
        klog.Errorf("將非結構化物件轉換為 HelmRelease 時發生錯誤: %v", err)
        return appsv1alpha1.Application{}, err
    }
    // ...
}

func (r *REST) ConvertHelmReleaseToApplication(hr *helmv2.HelmRelease) (appsv1alpha1.Application, error) {
    app, err := r.convertHelmReleaseToApplication(&helmRelease)
    if err != nil {
        klog.Errorf("Error converting from HelmRelease to Application: %v", err)
        return appsv1alpha1.Application{}, err
    }
    return app, nil
}

func (r *REST) convertHelmReleaseToApplication(hr *helmv2.HelmRelease) (appsv1alpha1.Application, error) {
    app := appsv1alpha1.Application{
        TypeMeta: metav1.TypeMeta{
            APIVersion: "apps.cozystack.io/v1alpha1",
            Kind:       r.kindName,
        },
        ObjectMeta: metav1.ObjectMeta{
            Name:              strings.TrimPrefix(hr.Name, r.releaseConfig.Prefix),
            Namespace:         hr.Namespace,
            // ... 其他元資料
        },
        Spec: hr.Spec.Values,
        Status: appsv1alpha1.ApplicationStatus{
            Version: hr.Status.LastAttemptedRevision,
        },
    }
}

var conditions []metav1.Condition
for _, hrCondition := range hr.GetConditions() {
    if hrCondition.Type == "Ready" || hrCondition.Type == "Released" {
        conditions = append(conditions, metav1.Condition{
            LastTransitionTime: hrCondition.LastTransitionTime,
            Reason:             hrCondition.Reason,
            Message:            hrCondition.Message,
            Status:             hrCondition.Status,
            Type:               hrCondition.Type,
        })
    }
}

func (r *REST) ConvertToTable(ctx context.Context, object runtime.Object, tableOptions runtime.Object) (*metav1.Table, error) {
    // ... 轉換邏輯
}

func (r *REST) buildTableFromApplications(apps []appsv1alpha1.Application) metav1.Table {
    table := metav1.Table{
        ColumnDefinitions: []metav1.TableColumnDefinition{
            {Name: "NAME", Type: "string", Description: "Name of the Application"},
            {Name: "READY", Type: "string", Description: "Ready status of the Application"},
            {Name: "AGE", Type: "string", Description: "Age of the Application"},
            {Name: "VERSION", Type: "string", Description: "Version of the Application"},
        },
        Rows: make([]metav1.TableRow, 0, len(apps)),
    }
    
    now := time.Now()
    for _, app := range apps {
        row := metav1.TableRow{
            Cells: []interface{}{
                app.GetName(),
                getReadyStatus(app.Status.Conditions),
                computeAge(app.GetCreationTimestamp().Time, now),
                getVersion(app.Status.Version),
            },
            Object: runtime.RawExtension{Object: &app},
        }
        table.Rows = append(table.Rows, row)
    }
    return table
}

func getVersion(version string) string {
    if version == "" {
        return "<unknown>"
    }
    return version
}

func computeAge(creationTime, currentTime time.Time) string {
    ageDuration := currentTime.Sub(creationTime)
    return duration.HumanDuration(ageDuration)
}

func getReadyStatus(conditions []metav1.Condition) string {
    for _, condition := range conditions {
        if condition.Type == "Ready" {
            switch condition.Status {
                case metav1.ConditionTrue:
                    return "True"
                case metav1.ConditionFalse:
                    return "False"
                default:
                    return "Unknown"
            }
        }
    }
    return "Unknown"
}

type REST struct {
    dynamicClient  dynamic.Interface
    gvr           schema.GroupVersionResource
    gvk           schema.GroupVersionKind
    kindName      string
    releaseConfig config.ReleaseConfig
}

func (r *REST) NamespaceScoped() bool {
    return true
}

func (r *REST) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) {
    app, ok := obj.(*appsv1alpha1.Application)
    if !ok {
        return nil, fmt.Errorf("expected Application object, got %T", obj)
    }
    
    helmRelease, err := r.ConvertApplicationToHelmRelease(app)
    if err != nil {
        klog.Errorf("Conversion error: %v", err)
        return nil, fmt.Errorf("conversion error: %v", err)
    }
}

if err != nil {
    return nil, apierrors.NewStatusError(
        http.StatusNotAcceptable,
        metav1.StatusReason("NotAcceptable"),
        e.Error(),
    )
}

const (
    LabelPrefix      = "apps.cozystack.io-"
    AnnotationPrefix = "apps.cozystack.io-"
)

var helmReleaseGVR = schema.GroupVersionResource{
    Group:    "helm.toolkit.fluxcd.io",
    Version:  "v2",
    Resource: "helmreleases",
}

func (r *REST) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) {
    app := obj.(*appsv1alpha1.Application)
    
    // 建立 HelmRelease
    helmRelease := &helmv2beta1.HelmRelease{
        ObjectMeta: metav1.ObjectMeta{
            Name:      r.releaseConfig.Prefix + app.Name,
            Namespace: app.Namespace,
        },
    }
    
    // 合併標籤
    helmRelease.Labels = mergeMaps(helmRelease.Labels, addPrefixedMap(app.Labels, LabelPrefix))
    
    // 轉換為非結構化格式
    unstructuredHR, err := runtime.DefaultUnstructuredConverter.ToUnstructured(helmRelease)
    if err != nil {
        return nil, fmt.Errorf("failed to convert HelmRelease to unstructured: %v", err)
    }
    
    // 在 Kubernetes 中建立 HelmRelease
    createdHR, err := r.dynamicClient.Resource(helmReleaseGVR).
        Namespace(app.Namespace).
        Create(ctx, &unstructured.Unstructured{Object: unstructuredHR}, *options)
}

func (r *REST) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
    namespace, err := r.getNamespace(ctx)
    if err != nil {
        return nil, err
    }
    
    // 檢索 HelmRelease
    helmReleaseName := r.releaseConfig.Prefix + name
    hr, err := r.dynamicClient.Resource(helmReleaseGVR).
        Namespace(namespace).
        Get(ctx, helmReleaseName, *options)
        
    // 檢查資源是否符合條件
    if !r.shouldIncludeHelmRelease(hr) {
        return nil, apierrors.NewNotFound(r.gvr.GroupResource(), name)
    }
    
    // 轉換並回傳資源
    convertedApp, err := r.ConvertHelmReleaseToApplication(hr)
}