mirror of
https://github.com/alibaba/higress.git
synced 2026-03-01 23:20:52 +08:00
288 lines
9.3 KiB
Go
288 lines
9.3 KiB
Go
// Copyright (c) 2022 Alibaba Group Holding Ltd.
|
|
//
|
|
// 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 helm
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
"sigs.k8s.io/yaml"
|
|
)
|
|
|
|
type InstallMode string
|
|
|
|
const (
|
|
InstallK8s InstallMode = "k8s"
|
|
InstallLocalK8s InstallMode = "local-k8s"
|
|
InstallLocalDocker InstallMode = "local-docker"
|
|
InstallLocal InstallMode = "local"
|
|
)
|
|
|
|
type Profile struct {
|
|
Profile string `json:"profile,omitempty"`
|
|
InstallPackagePath string `json:"installPackagePath,omitempty"`
|
|
Global ProfileGlobal `json:"global,omitempty"`
|
|
Console ProfileConsole `json:"console,omitempty"`
|
|
Gateway ProfileGateway `json:"gateway,omitempty"`
|
|
Controller ProfileController `json:"controller,omitempty"`
|
|
Storage ProfileStorage `json:"storage,omitempty"`
|
|
Values map[string]any `json:"values,omitempty"`
|
|
Charts ProfileCharts `json:"charts,omitempty"`
|
|
}
|
|
|
|
type ProfileGlobal struct {
|
|
Install InstallMode `json:"install,omitempty"`
|
|
IngressClass string `json:"ingressClass,omitempty"`
|
|
WatchNamespace string `json:"watchNamespace,omitempty"`
|
|
DisableAlpnH2 bool `json:"disableAlpnH2,omitempty"`
|
|
EnableStatus bool `json:"enableStatus,omitempty"`
|
|
EnableIstioAPI bool `json:"enableIstioAPI,omitempty"`
|
|
Namespace string `json:"namespace,omitempty"`
|
|
IstioNamespace string `json:"istioNamespace,omitempty"`
|
|
}
|
|
|
|
func (p ProfileGlobal) SetFlags(install InstallMode) ([]string, error) {
|
|
sets := make([]string, 0)
|
|
sets = append(sets, fmt.Sprintf("global.ingressClass=%s", p.IngressClass))
|
|
sets = append(sets, fmt.Sprintf("global.watchNamespace=%s", p.WatchNamespace))
|
|
sets = append(sets, fmt.Sprintf("global.disableAlpnH2=%t", p.DisableAlpnH2))
|
|
sets = append(sets, fmt.Sprintf("global.enableStatus=%t", p.EnableStatus))
|
|
sets = append(sets, fmt.Sprintf("global.enableIstioAPI=%t", p.EnableIstioAPI))
|
|
sets = append(sets, fmt.Sprintf("global.istioNamespace=%s", p.IstioNamespace))
|
|
if install == InstallLocalK8s {
|
|
sets = append(sets, fmt.Sprintf("global.local=%t", true))
|
|
}
|
|
return sets, nil
|
|
}
|
|
|
|
func (p ProfileGlobal) Validate(install InstallMode) []error {
|
|
errs := make([]error, 0)
|
|
// now only support k8s and local-k8s installation mode
|
|
if p.Install != InstallK8s && p.Install != InstallLocalK8s {
|
|
errs = append(errs, errors.New("global.install only can be set to k8s or local-k8s"))
|
|
}
|
|
if len(p.IngressClass) == 0 {
|
|
errs = append(errs, errors.New("global.ingressClass can't be empty"))
|
|
}
|
|
if len(p.Namespace) == 0 {
|
|
errs = append(errs, errors.New("global.namespace can't be empty"))
|
|
}
|
|
if len(p.IstioNamespace) == 0 {
|
|
errs = append(errs, errors.New("global.istioNamespace can't be empty"))
|
|
}
|
|
return errs
|
|
}
|
|
|
|
type ProfileConsole struct {
|
|
Port uint32 `json:"port,omitempty"`
|
|
Replicas uint32 `json:"replicas,omitempty"`
|
|
ServiceType string `json:"serviceType,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
TlsSecretName string `json:"tlsSecretName,omitempty"`
|
|
WebLoginPrompt string `json:"webLoginPrompt,omitempty"`
|
|
AdminPasswordValue string `json:"adminPasswordValue,omitempty"`
|
|
AdminPasswordLength uint32 `json:"adminPasswordLength,omitempty"`
|
|
O11yEnabled bool `json:"o11YEnabled,omitempty"`
|
|
PvcRwxSupported bool `json:"pvcRwxSupported,omitempty"`
|
|
}
|
|
|
|
func (p ProfileConsole) SetFlags(install InstallMode) ([]string, error) {
|
|
sets := make([]string, 0)
|
|
sets = append(sets, fmt.Sprintf("higress-console.replicaCount=%d", p.Replicas))
|
|
sets = append(sets, fmt.Sprintf("higress-console.service.type=%s", p.ServiceType))
|
|
sets = append(sets, fmt.Sprintf("higress-console.domain=%s", p.Domain))
|
|
sets = append(sets, fmt.Sprintf("higress-console.tlsSecretName=%s", p.TlsSecretName))
|
|
sets = append(sets, fmt.Sprintf("higress-console.web.login.prompt=%s", p.WebLoginPrompt))
|
|
sets = append(sets, fmt.Sprintf("higress-console.admin.password.value=%s", p.AdminPasswordValue))
|
|
sets = append(sets, fmt.Sprintf("higress-console.admin.password.length=%d", p.AdminPasswordLength))
|
|
sets = append(sets, fmt.Sprintf("higress-console.o11y.enabled=%t", p.O11yEnabled))
|
|
sets = append(sets, fmt.Sprintf("higress-console.pvc.rwxSupported=%t", p.PvcRwxSupported))
|
|
return sets, nil
|
|
}
|
|
|
|
func (p ProfileConsole) Validate(install InstallMode) []error {
|
|
errs := make([]error, 0)
|
|
if p.Replicas <= 0 {
|
|
errs = append(errs, errors.New("console.replica need be large than zero"))
|
|
}
|
|
|
|
if p.ServiceType != "ClusterIP" && p.ServiceType != "NodePort" && p.ServiceType != "LoadBalancer" {
|
|
errs = append(errs, errors.New("console.serviceType can only be set to ClusterIP, NodePort or LoadBalancer"))
|
|
}
|
|
|
|
return errs
|
|
}
|
|
|
|
type ProfileGateway struct {
|
|
Replicas uint32 `json:"replicas,omitempty"`
|
|
HttpPort uint32 `json:"httpPort,omitempty"`
|
|
HttpsPort uint32 `json:"httpsPort,omitempty"`
|
|
MetricsPort uint32 `json:"metricsPort,omitempty"`
|
|
}
|
|
|
|
func (p ProfileGateway) SetFlags(install InstallMode) ([]string, error) {
|
|
sets := make([]string, 0)
|
|
sets = append(sets, fmt.Sprintf("higress-core.gateway.replicas=%d", p.Replicas))
|
|
return sets, nil
|
|
}
|
|
|
|
func (p ProfileGateway) Validate(install InstallMode) []error {
|
|
errs := make([]error, 0)
|
|
if p.Replicas <= 0 {
|
|
errs = append(errs, errors.New("gateway.replica need be large than zero"))
|
|
}
|
|
|
|
return errs
|
|
}
|
|
|
|
type ProfileController struct {
|
|
Replicas uint32 `json:"replicas,omitempty"`
|
|
}
|
|
|
|
func (p ProfileController) SetFlags(install InstallMode) ([]string, error) {
|
|
sets := make([]string, 0)
|
|
sets = append(sets, fmt.Sprintf("higress-core.controller.replicas=%d", p.Replicas))
|
|
return sets, nil
|
|
}
|
|
|
|
func (p ProfileController) Validate(install InstallMode) []error {
|
|
errs := make([]error, 0)
|
|
if p.Replicas <= 0 {
|
|
errs = append(errs, errors.New("controller.replica need be large than zero"))
|
|
}
|
|
|
|
return errs
|
|
}
|
|
|
|
type ProfileStorage struct {
|
|
Url string `json:"url,omitempty"`
|
|
Ns string `json:"ns,omitempty"`
|
|
Username string `json:"username,omitempty"`
|
|
Password string `json:"password,omitempty"`
|
|
DataEncKey string `json:"DataEncKey,omitempty"`
|
|
}
|
|
|
|
func (p ProfileStorage) Validate(install InstallMode) []error {
|
|
errs := make([]error, 0)
|
|
return errs
|
|
}
|
|
|
|
type Chart struct {
|
|
Url string `json:"url,omitempty"`
|
|
Name string `json:"name,omitempty"`
|
|
Version string `json:"version,omitempty"`
|
|
}
|
|
|
|
type ProfileCharts struct {
|
|
Higress Chart `json:"higress,omitempty"`
|
|
Istio Chart `json:"istio,omitempty"`
|
|
}
|
|
|
|
func (p ProfileCharts) Validate(install InstallMode) []error {
|
|
errs := make([]error, 0)
|
|
|
|
return errs
|
|
}
|
|
|
|
func (p *Profile) ValuesYaml() (string, error) {
|
|
setFlags := make([]string, 0)
|
|
// Get global setting
|
|
globalFlags, _ := p.Global.SetFlags(p.Global.Install)
|
|
setFlags = append(setFlags, globalFlags...)
|
|
|
|
// Get console setting
|
|
consoleFlags, _ := p.Console.SetFlags(p.Global.Install)
|
|
setFlags = append(setFlags, consoleFlags...)
|
|
|
|
// Get gateway setting
|
|
gatewayFlags, _ := p.Gateway.SetFlags(p.Global.Install)
|
|
setFlags = append(setFlags, gatewayFlags...)
|
|
|
|
// Get controller setting
|
|
controllerFlags, _ := p.Controller.SetFlags(p.Global.Install)
|
|
setFlags = append(setFlags, controllerFlags...)
|
|
|
|
valueOverlayYAML := ""
|
|
if p.Values != nil {
|
|
out, err := yaml.Marshal(p.Values)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
valueOverlayYAML = string(out)
|
|
}
|
|
// merge values and setFlags
|
|
overlayYAML, err := overlaySetFlagValues(valueOverlayYAML, setFlags)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return overlayYAML, nil
|
|
}
|
|
|
|
func (p *Profile) IstioEnabled() bool {
|
|
if (p.Global.Install == InstallK8s || p.Global.Install == InstallLocalK8s) && p.Global.EnableIstioAPI {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *Profile) Validate() error {
|
|
errs := make([]error, 0)
|
|
errsGlobal := p.Global.Validate(p.Global.Install)
|
|
if len(errsGlobal) > 0 {
|
|
errs = append(errs, errsGlobal...)
|
|
}
|
|
errsConsole := p.Console.Validate(p.Global.Install)
|
|
if len(errsConsole) > 0 {
|
|
errs = append(errs, errsConsole...)
|
|
}
|
|
errsGateway := p.Gateway.Validate(p.Global.Install)
|
|
if len(errsGateway) > 0 {
|
|
errs = append(errs, errsGateway...)
|
|
}
|
|
errsController := p.Controller.Validate(p.Global.Install)
|
|
if len(errsController) > 0 {
|
|
errs = append(errs, errsController...)
|
|
}
|
|
errsStorage := p.Storage.Validate(p.Global.Install)
|
|
if len(errsController) > 0 {
|
|
errs = append(errs, errsStorage...)
|
|
}
|
|
errsCharts := p.Charts.Validate(p.Global.Install)
|
|
if len(errsCharts) > 0 {
|
|
errs = append(errs, errsCharts...)
|
|
}
|
|
|
|
if len(errs) == 0 {
|
|
return nil
|
|
}
|
|
return errors.New(ToString(errs, "\n"))
|
|
}
|
|
|
|
// ToString returns a string representation of errors, with elements separated by separator string. Any nil errors in the
|
|
// slice are skipped.
|
|
func ToString(errors []error, separator string) string {
|
|
var out string
|
|
for i, e := range errors {
|
|
if e == nil {
|
|
continue
|
|
}
|
|
if i != 0 {
|
|
out += separator
|
|
}
|
|
out += e.Error()
|
|
}
|
|
return out
|
|
}
|