func()

in pkg/ingress/config/ingress_config.go [933:1069]
133 lines of code
20 McCabe index (conditional complexity)

func (m *IngressConfig) convertIstioWasmPlugin(obj *higressext.WasmPlugin) (*extensions.WasmPlugin, error) {
	result := &extensions.WasmPlugin{
		Selector: &istiotype.WorkloadSelector{
			MatchLabels: map[string]string{
				m.commonOptions.GatewaySelectorKey: m.commonOptions.GatewaySelectorValue,
			},
		},
		Url:             obj.Url,
		Sha256:          obj.Sha256,
		ImagePullPolicy: extensions.PullPolicy(obj.ImagePullPolicy),
		ImagePullSecret: obj.ImagePullSecret,
		VerificationKey: obj.VerificationKey,
		PluginConfig:    obj.PluginConfig,
		PluginName:      obj.PluginName,
		Phase:           extensions.PluginPhase(obj.Phase),
		FailStrategy:    extensions.FailStrategy(obj.FailStrategy),
		Priority:        obj.Priority,
	}
	if obj.VmConfig != nil {
		result.VmConfig = &extensions.VmConfig{}
		for _, env := range obj.VmConfig.Env {
			result.VmConfig.Env = append(result.VmConfig.Env, &extensions.EnvVar{
				Name:      env.Name,
				ValueFrom: extensions.EnvValueSource(env.ValueFrom),
				Value:     env.Value,
			})
		}
	}
	if result.PluginConfig != nil {
		return result, nil
	}
	if !isBoolValueTrue(obj.DefaultConfigDisable) {
		result.PluginConfig = obj.DefaultConfig
	}
	hasValidRule := false
	if len(obj.MatchRules) > 0 {
		if result.PluginConfig == nil {
			result.PluginConfig = &_struct.Struct{
				Fields: map[string]*_struct.Value{},
			}
		}
		var ruleValues []*_struct.Value
		for _, rule := range obj.MatchRules {
			if isBoolValueTrue(rule.ConfigDisable) {
				continue
			}
			if rule.Config == nil {
				rule.Config = &_struct.Struct{
					Fields: map[string]*_struct.Value{},
				}
			}
			v := &_struct.Value_StructValue{
				StructValue: rule.Config,
			}

			validRule := false
			var matchItems []*_struct.Value
			// match ingress
			for _, ing := range rule.Ingress {
				matchItems = append(matchItems, &_struct.Value{
					Kind: &_struct.Value_StringValue{
						StringValue: ing,
					},
				})
			}
			if len(matchItems) > 0 {
				validRule = true
				v.StructValue.Fields["_match_route_"] = &_struct.Value{
					Kind: &_struct.Value_ListValue{
						ListValue: &_struct.ListValue{
							Values: matchItems,
						},
					},
				}
			}
			// match service
			matchItems = nil
			for _, service := range rule.Service {
				matchItems = append(matchItems, &_struct.Value{
					Kind: &_struct.Value_StringValue{
						StringValue: service,
					},
				})
			}
			if len(matchItems) > 0 {
				validRule = true
				v.StructValue.Fields["_match_service_"] = &_struct.Value{
					Kind: &_struct.Value_ListValue{
						ListValue: &_struct.ListValue{
							Values: matchItems,
						},
					},
				}
			}
			// match domain
			matchItems = nil
			for _, domain := range rule.Domain {
				matchItems = append(matchItems, &_struct.Value{
					Kind: &_struct.Value_StringValue{
						StringValue: domain,
					},
				})
			}
			if len(matchItems) > 0 {
				validRule = true
				v.StructValue.Fields["_match_domain_"] = &_struct.Value{
					Kind: &_struct.Value_ListValue{
						ListValue: &_struct.ListValue{
							Values: matchItems,
						},
					},
				}
			}
			if validRule {
				ruleValues = append(ruleValues, &_struct.Value{
					Kind: v,
				})
			} else {
				return nil, fmt.Errorf("invalid match rule has no match condition, rule:%v", rule)
			}
		}
		if len(ruleValues) > 0 {
			hasValidRule = true
			result.PluginConfig.Fields["_rules_"] = &_struct.Value{
				Kind: &_struct.Value_ListValue{
					ListValue: &_struct.ListValue{
						Values: ruleValues,
					},
				},
			}
		}
	}
	if !hasValidRule && isBoolValueTrue(obj.DefaultConfigDisable) {
		return nil, nil
	}
	return result, nil
}