github.com/verrazzano/verrazzano@v1.7.1/tools/psr/psrctl/pkg/scenario/start.go (about) 1 // Copyright (c) 2022, 2023, Oracle and/or its affiliates. 2 // Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl. 3 4 package scenario 5 6 import ( 7 "fmt" 8 "os" 9 "path/filepath" 10 "strings" 11 12 helmcli "github.com/verrazzano/verrazzano/pkg/helm" 13 "github.com/verrazzano/verrazzano/tools/psr/psrctl/pkg/manifest" 14 "github.com/verrazzano/verrazzano/tools/vz/pkg/helpers" 15 "k8s.io/apimachinery/pkg/types" 16 "sigs.k8s.io/yaml" 17 ) 18 19 var StartUpgradeFunc = helmcli.Upgrade 20 21 // WorkerType is used to get the worker type from the worker use case YAML file. 22 // Note: struct and fields must be public for YAML unmarshal to work. 23 type WorkerType struct { 24 Global struct { 25 EnvVars struct { 26 WorkerType string `json:"PSR_WORKER_TYPE"` 27 } 28 } 29 } 30 31 // StartScenario starts a Scenario 32 func (m ScenarioMananger) StartScenario(manifestMan manifest.ManifestManager, scman *manifest.ScenarioManifest, vzHelper helpers.VZHelper) (string, error) { 33 helmReleases := []HelmRelease{} 34 35 // Make sure the scenario is not running already 36 running, err := m.FindRunningScenarios() 37 if err != nil { 38 return "", err 39 } 40 for _, sc := range running { 41 if strings.EqualFold(sc.ID, scman.ID) { 42 return "", fmt.Errorf("Scenario %s already running in namespace %s", sc.ID, m.Namespace) 43 } 44 } 45 46 // Helm install each use case 47 var i int 48 for _, uc := range scman.Usecases { 49 // Create the set of HelmOverrides, initialized from the manager settings 50 helmOverrides := m.HelmOverrides 51 52 // Build the usecase path, E.G. manifests/usecases/opensearch/getlogs/getlogs.yaml 53 ucOverride := filepath.Join(manifestMan.Manifest.UseCasesAbsDir, uc.UsecasePath) 54 helmOverrides = append(helmOverrides, helmcli.HelmOverrides{FileOverride: ucOverride}) 55 56 // Build scenario override path for the use case, E.G manifests/scenarios/opensearch/s1/usecase-overrides/getlogs-fast.yaml 57 scOverride := filepath.Join(scman.ScenarioUsecaseOverridesAbsDir, uc.OverrideFile) 58 helmOverrides = append(helmOverrides, helmcli.HelmOverrides{FileOverride: scOverride}) 59 60 wType, err := readWorkerType(ucOverride) 61 if err != nil { 62 return "", err 63 } 64 65 // Build release name psr-<scenarioID>-workertype-<index> 66 relname := fmt.Sprintf("psr-%s-%s-%v", scman.ID, wType, i) 67 68 if m.Verbose { 69 fmt.Fprintf(vzHelper.GetOutputStream(), "Installing use case %s as Helm release %s/%s\n", uc.UsecasePath, m.Namespace, relname) 70 } 71 _, err = StartUpgradeFunc(m.Log, relname, m.Namespace, manifestMan.Manifest.WorkerChartAbsDir, true, m.DryRun, helmOverrides) 72 if err != nil { 73 return err.Error(), err 74 } 75 76 // Save the HelmRelease info 77 helmRelease := HelmRelease{ 78 NamespacedName: types.NamespacedName{ 79 Namespace: m.Namespace, 80 Name: relname, 81 }, 82 Usecase: uc, 83 } 84 helmReleases = append(helmReleases, helmRelease) 85 i++ 86 } 87 88 // Save the scenario in a ConfigMap 89 sc := Scenario{ 90 Namespace: m.Namespace, 91 HelmReleases: helmReleases, 92 ScenarioManifest: scman, 93 } 94 _, err = m.createConfigMap(sc) 95 if err != nil { 96 return "", err 97 } 98 return "", nil 99 } 100 101 // readWorkerType reads the worker type from the use case worker YAML file at psr/manifests/usecases/... 102 func readWorkerType(ucOverride string) (string, error) { 103 // Read in the manifests/usecases/.. YAML file to get the worker type 104 var wt WorkerType 105 data, err := os.ReadFile(ucOverride) 106 if err != nil { 107 return "nil", fmt.Errorf("Failed to read use case override file %s: %v", ucOverride, err) 108 } 109 if err := yaml.Unmarshal(data, &wt); err != nil { 110 return "nil", fmt.Errorf("Failed to parse use case override file %s: %v", ucOverride, err) 111 } 112 if len(wt.Global.EnvVars.WorkerType) == 0 { 113 return "nil", fmt.Errorf("Failed to find global.envVars.PSR_WORKER_TYPE in %s", ucOverride) 114 } 115 return wt.Global.EnvVars.WorkerType, nil 116 }