Commit 4275508d authored by Vasilis Katopodis's avatar Vasilis Katopodis
Browse files

refactor: rename P2Code scheduling manifest to Hypo

parent bf58faa3
Loading
Loading
Loading
Loading
Loading
+1 −1
Changes for Makefile: 1 added line, 1 removed line.
Original line number Diff line number Diff line
# Makefile for pkg-manager.helm.
#
# This is a plain Go service (no CRDs/controller-runtime), so unlike
# p2code_scheduler_operator's Makefile there is no manifests/generate/kustomize/
# ocm_scheduler_operator's Makefile there is no manifests/generate/kustomize/
# envtest/bundle/catalog scaffolding here - those are operator-sdk/OLM concerns
# that don't apply to this repo.

+13 −9
Changes for README.md: 13 added lines, 9 removed lines.
Original line number Diff line number Diff line
@@ -96,7 +96,7 @@ The source type is detected from the shape of `serviceRepositoryURL` and `servic
| `….git` with a `.yml` identifier       | Git repo with a compose file | Docker Compose → Helm (Kompose) |
| `….git`                                | Git repo with K8s manifests  | Kubernetes manifests → Helm (Kompose) |

If the source repository is private, the handler routes to the Registry API (via `get-package-registry-incoming-channel`) to retrieve credentials before fetching the chart. For OCM-based multi-cluster deployments (`clusterManager: "ocm"`), it also routes through Registry API, passing the scheduler namespace read from `clusterMetadata`, and the chart is rewritten into a P2Code `ManifestWork` before it is stored.
If the source repository is private, the handler routes to the Registry API (via `get-package-registry-incoming-channel`) to retrieve credentials before fetching the chart. For OCM-based multi-cluster deployments (`clusterManager: "ocm"`), it also routes through Registry API, passing the scheduler namespace read from `clusterMetadata`, and the chart is rewritten into a `HypoSchedulingManifest` before it is stored.

Upon success, the handler publishes a response to `helm-engine-parse-result`:

@@ -281,25 +281,29 @@ For the OCM scheduler chart itself (installed on the hub as a plain Helm order,

During the parse phase, the Package Manager decodes `clusterMetadata`, extracts the `namespace` field, and stores it as the Helm chart annotation `sonata.engine/namespace`. This annotation is then read by the deploy, activate, and terminate handlers to determine the correct namespace of the OCM scheduler, instead of defaulting to the `serviceId`.

An example `clusterMetadata` payload (after Base64 decoding) for the **P2CODE** scheduler:
An example `clusterMetadata` payload (after Base64 decoding) for the **Hypo** OCM scheduler:

```yaml
apiVersion: scheduling.p2code.eu/v1alpha1
kind: P2CodeSchedulingManifest
apiVersion: scheduling.hypo.eu/v1alpha1
kind: HypoSchedulingManifest
metadata:
  name: poc
  namespace: p2code-scheduler-system
  name: hypo-scheduler-test
  namespace: hypo-scheduler-system
spec:
  globalAnnotations:
    - hypo.target.managedClusterSet=test
  workloadAnnotations:
    - name: httpd
      annotations:
        - p2code.filter.k8sdistribution=openshift
        - hypo.filter.location=athens
    - name: nginx
      annotations:
        - p2code.filter.k8sdistribution=kubernetes
        - hypo.filter.location=patra
```

The `namespace` field (`p2code-scheduler-system` above) becomes the deployment namespace. During termination with OCM, the namespace is intentionally kept alive because the OCM scheduler manages its lifecycle.
`spec.manifests` is filled in from the rendered chart; any `manifests` already in `clusterMetadata` are replaced.

The `namespace` field (`hypo-scheduler-system` above) becomes the deployment namespace. During termination with OCM, the namespace is intentionally kept alive because the OCM scheduler manages its lifecycle.

---

+1 −1
Changes for adapters/chart_converter.go: 1 added line, 1 removed line.
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ type ChartConverter interface {

func getChartConverter(serviceID, clusterManager, clusterMetadata string) ChartConverter {
	if ClusterManager(strings.ToUpper(clusterManager)) == OCM {
		return &P2CodeAdapter{
		return &HypoAdapter{
			clusterMetadata: clusterMetadata,
		}
	}
+10 −10
Changes for adapters/chart_converter_test.go: 10 added lines, 10 removed lines.
Original line number Diff line number Diff line
@@ -17,13 +17,13 @@ func (m *mockLogger) Warning(msg string, args ...any) {}
func (m *mockLogger) Error(err error, msg string, args ...any) {}
func (m *mockLogger) SetLogLevel(level string) error           { return nil }

type MockP2CodeAdapter struct{}
type MockHypoAdapter struct{}

func (m *MockP2CodeAdapter) convert(log logging.Logger, serviceID string, chartData []byte, valuesYAML string) ([]byte, error) {
func (m *MockHypoAdapter) convert(log logging.Logger, serviceID string, chartData []byte, valuesYAML string) ([]byte, error) {
	if valuesYAML != "" {
		return []byte("mock p2code output with values"), nil
		return []byte("mock hypo output with values"), nil
	}
	return []byte("mock p2code output"), nil
	return []byte("mock hypo output"), nil
}

type MockHelmChartAdapter struct{}
@@ -40,8 +40,8 @@ func TestGetChartConverter(t *testing.T) {
		clusterMetadata string
		expectedType    ChartConverter
	}{
		{"OCM with metadata", "service1", "ocm", "metadata", &P2CodeAdapter{}},
		{"OCM without metadata", "service2", "ocm", "", &P2CodeAdapter{}},
		{"OCM with metadata", "service1", "ocm", "metadata", &HypoAdapter{}},
		{"OCM without metadata", "service2", "ocm", "", &HypoAdapter{}},
		{"Non-OCM clusterManager", "service3", "other", "metadata", &HelmChartAdapter{}},
	}

@@ -49,7 +49,7 @@ func TestGetChartConverter(t *testing.T) {
		t.Run(tt.name, func(t *testing.T) {
			var converter ChartConverter
			if tt.clusterManager == "ocm" {
				converter = &P2CodeAdapter{}
				converter = &HypoAdapter{}
			} else {
				converter = &HelmChartAdapter{}
			}
@@ -79,13 +79,13 @@ func TestConvertChart(t *testing.T) {
			"OCM conversion (no values)",
			"service1", "ocm", "metadata",
			[]byte("input"), "",
			[]byte("mock p2code output"), nil,
			[]byte("mock hypo output"), nil,
		},
		{
			"OCM conversion (with values)",
			"service1", "ocm", "metadata",
			[]byte("input"), "base64-values-string",
			[]byte("mock p2code output with values"), nil,
			[]byte("mock hypo output with values"), nil,
		},
		{
			"Helm conversion (no values)",
@@ -105,7 +105,7 @@ func TestConvertChart(t *testing.T) {
		t.Run(tt.name, func(t *testing.T) {
			var converter ChartConverter
			if tt.clusterManager == "ocm" {
				converter = &MockP2CodeAdapter{}
				converter = &MockHypoAdapter{}
			} else {
				converter = &MockHelmChartAdapter{}
			}
+15 −15
Changes for adapters/hypo_adapter.go: 15 added lines, 15 removed lines.
Original line number Diff line number Diff line
@@ -21,12 +21,12 @@ import (
	"labs.etsi.org/rep/osl/hypo/code/org.etsi.osl.hypo.core/pkg-manager.helm/internal/logging"
)

type P2CodeAdapter struct {
type HypoAdapter struct {
	clusterMetadata string
}

func (p *P2CodeAdapter) convert(log logging.Logger, serviceID string, chartData []byte, valuesYAML string) ([]byte, error) {
	log.Info("service_id=%s msg=\"Executing P2CodeAdapter conversion for OCM deployment.\"", serviceID)
func (p *HypoAdapter) convert(log logging.Logger, serviceID string, chartData []byte, valuesYAML string) ([]byte, error) {
	log.Info("service_id=%s msg=\"Executing HypoAdapter conversion for OCM deployment.\"", serviceID)

	log.Debug("service_id=%s msg=\"Loading chart archive into memory.\"", serviceID)
	charts, err := loader.LoadArchive(bytes.NewReader(chartData))
@@ -46,15 +46,15 @@ func (p *P2CodeAdapter) convert(log logging.Logger, serviceID string, chartData
		return nil, fmt.Errorf("failed to Helm template: %w", err)
	}

	log.Debug("service_id=%s msg=\"Creating P2Code Scheduling Manifest (ManifestWork).\"", serviceID)
	manifestWork, err := createP2CodeSchedulingManifest(release.Manifest, p.clusterMetadata)
	log.Debug("service_id=%s msg=\"Creating Hypo Scheduling Manifest (ManifestWork).\"", serviceID)
	manifestWork, err := createHypoSchedulingManifest(release.Manifest, p.clusterMetadata)
	if err != nil {
		return nil, fmt.Errorf("failed to create ManifestWork: %w", err)
	}

	yamlFile := generateYamlFileName("/tmp", "manifestwork", serviceID)
	log.Debug("service_id=%s msg=\"Saving P2Code YAML file to disk: %s\"", serviceID, yamlFile)
	err = saveP2CodeYAMLFile(manifestWork, yamlFile)
	log.Debug("service_id=%s msg=\"Saving Hypo YAML file to disk: %s\"", serviceID, yamlFile)
	err = saveHypoYAMLFile(manifestWork, yamlFile)
	if err != nil {
		return nil, fmt.Errorf("failed to save YAML file: %w", err)
	}
@@ -77,16 +77,16 @@ func (p *P2CodeAdapter) convert(log logging.Logger, serviceID string, chartData
		return nil, fmt.Errorf("failed to read TGZ file: %w", err)
	}

	log.Info("service_id=%s msg=\"Successfully completed P2Code OCM chart conversion.\"", serviceID)
	log.Info("service_id=%s msg=\"Successfully completed Hypo OCM chart conversion.\"", serviceID)
	return data, nil
}

func createP2CodeSchedulingManifest(manifestsYAML string, p2CodeSchedulingManifestBase64 string) (*datamodel.P2CodeSchedulingManifest, error) {
func createHypoSchedulingManifest(manifestsYAML string, hypoSchedulingManifestBase64 string) (*datamodel.HypoSchedulingManifest, error) {
	var manifests []datamodel.IManifest

	p2CodeSchedulingManifestBytes, err := base64.StdEncoding.DecodeString(p2CodeSchedulingManifestBase64)
	hypoSchedulingManifestBytes, err := base64.StdEncoding.DecodeString(hypoSchedulingManifestBase64)
	if err != nil {
		return nil, errors.New("failed to decode p2CodeSchedulingManifest from base64: " + err.Error())
		return nil, errors.New("failed to decode hypoSchedulingManifest from base64: " + err.Error())
	}

	decoder := yaml.NewDecoder(bytes.NewReader([]byte(manifestsYAML)))
@@ -110,8 +110,8 @@ func createP2CodeSchedulingManifest(manifestsYAML string, p2CodeSchedulingManife
		manifests = append(manifests, doc)
	}

	var manifestWork datamodel.P2CodeSchedulingManifest
	decoder = yaml.NewDecoder(bytes.NewReader(p2CodeSchedulingManifestBytes))
	var manifestWork datamodel.HypoSchedulingManifest
	decoder = yaml.NewDecoder(bytes.NewReader(hypoSchedulingManifestBytes))
	err = decoder.Decode(&manifestWork)
	if err != nil {
		return nil, err
@@ -139,8 +139,8 @@ func convertKubernetesToHelm(yamlFile, serviceID string) (string, error) {
	return helmChartsPath, nil
}

// saveP2CodeYAMLFile saves a P2CodeSchedulingManifest to a YAML file
func saveP2CodeYAMLFile(data *datamodel.P2CodeSchedulingManifest, filename string) error {
// saveHypoYAMLFile saves a HypoSchedulingManifest to a YAML file
func saveHypoYAMLFile(data *datamodel.HypoSchedulingManifest, filename string) error {
	out, err := yaml.Marshal(data)
	if err != nil {
		return err
Loading