istio: istio.io/istio/mixer/template/sample Index | Files | Directories

package sample

import "istio.io/istio/mixer/template/sample"

Package sample provides a set of templates for internal testing of Mixer. Templates under this directory are for Mixer's internal testing purpose *ONLY*.

Index

Package Files

doc.go template.gen.go

Variables

var (
    SupportedTmplInfo = map[string]template.Info{

        istio_mixer_adapter_sample_myapa.TemplateName: {
            Name:               istio_mixer_adapter_sample_myapa.TemplateName,
            Impl:               "istio.mixer.adapter.sample.myapa",
            CtrCfg:             &istio_mixer_adapter_sample_myapa.InstanceParam{},
            Variety:            istio_adapter_model_v1beta1.TEMPLATE_VARIETY_ATTRIBUTE_GENERATOR,
            BldrInterfaceName:  istio_mixer_adapter_sample_myapa.TemplateName + "." + "HandlerBuilder",
            HndlrInterfaceName: istio_mixer_adapter_sample_myapa.TemplateName + "." + "Handler",
            BuilderSupportsTemplate: func(hndlrBuilder adapter.HandlerBuilder) bool {
                _, ok := hndlrBuilder.(istio_mixer_adapter_sample_myapa.HandlerBuilder)
                return ok
            },
            HandlerSupportsTemplate: func(hndlr adapter.Handler) bool {
                _, ok := hndlr.(istio_mixer_adapter_sample_myapa.Handler)
                return ok
            },
            InferType: func(cp proto.Message, tEvalFn template.TypeEvalFn) (proto.Message, error) {

                var BuildTemplate func(param *istio_mixer_adapter_sample_myapa.InstanceParam,
                    path string) (proto.Message, error)

                _ = BuildTemplate

                var BuildResource1 func(param *istio_mixer_adapter_sample_myapa.Resource1InstanceParam,
                    path string) (proto.Message, error)

                _ = BuildResource1

                var BuildResource2 func(param *istio_mixer_adapter_sample_myapa.Resource2InstanceParam,
                    path string) (proto.Message, error)

                _ = BuildResource2

                var BuildResource3 func(param *istio_mixer_adapter_sample_myapa.Resource3InstanceParam,
                    path string) (proto.Message, error)

                _ = BuildResource3

                BuildTemplate = func(param *istio_mixer_adapter_sample_myapa.InstanceParam,
                    path string) (proto.Message, error) {

                    if param == nil {
                        return nil, nil
                    }

                    var err error = nil

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.BoolPrimitive != "" {
                        if t, e := tEvalFn(param.BoolPrimitive); e != nil || t != istio_policy_v1beta1.BOOL {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"BoolPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"BoolPrimitive", t, istio_policy_v1beta1.BOOL)
                        }
                    }

                    if param.DoublePrimitive != "" {
                        if t, e := tEvalFn(param.DoublePrimitive); e != nil || t != istio_policy_v1beta1.DOUBLE {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"DoublePrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"DoublePrimitive", t, istio_policy_v1beta1.DOUBLE)
                        }
                    }

                    if param.StringPrimitive != "" {
                        if t, e := tEvalFn(param.StringPrimitive); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"StringPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"StringPrimitive", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    for k, v := range param.DimensionsFixedInt64ValueDType {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "DimensionsFixedInt64ValueDType", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "DimensionsFixedInt64ValueDType", k, t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.TimeStamp != "" {
                        if t, e := tEvalFn(param.TimeStamp); e != nil || t != istio_policy_v1beta1.TIMESTAMP {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"TimeStamp", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"TimeStamp", t, istio_policy_v1beta1.TIMESTAMP)
                        }
                    }

                    if param.Duration != "" {
                        if t, e := tEvalFn(param.Duration); e != nil || t != istio_policy_v1beta1.DURATION {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Duration", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Duration", t, istio_policy_v1beta1.DURATION)
                        }
                    }

                    if param.OptionalIP != "" {
                        if t, e := tEvalFn(param.OptionalIP); e != nil || t != istio_policy_v1beta1.IP_ADDRESS {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"OptionalIP", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"OptionalIP", t, istio_policy_v1beta1.IP_ADDRESS)
                        }
                    }

                    if param.Email != "" {
                        if t, e := tEvalFn(param.Email); e != nil || t != istio_policy_v1beta1.EMAIL_ADDRESS {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Email", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Email", t, istio_policy_v1beta1.EMAIL_ADDRESS)
                        }
                    }

                    return nil, err

                }

                BuildResource1 = func(param *istio_mixer_adapter_sample_myapa.Resource1InstanceParam,
                    path string) (proto.Message, error) {

                    if param == nil {
                        return nil, nil
                    }

                    var err error = nil

                    if param.Str != "" {
                        if t, e := tEvalFn(param.Str); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Str", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Str", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    return nil, err

                }

                BuildResource2 = func(param *istio_mixer_adapter_sample_myapa.Resource2InstanceParam,
                    path string) (proto.Message, error) {

                    if param == nil {
                        return nil, nil
                    }

                    var err error = nil

                    if param.Str != "" {
                        if t, e := tEvalFn(param.Str); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Str", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Str", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    return nil, err

                }

                BuildResource3 = func(param *istio_mixer_adapter_sample_myapa.Resource3InstanceParam,
                    path string) (proto.Message, error) {

                    if param == nil {
                        return nil, nil
                    }

                    var err error = nil

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.BoolPrimitive != "" {
                        if t, e := tEvalFn(param.BoolPrimitive); e != nil || t != istio_policy_v1beta1.BOOL {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"BoolPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"BoolPrimitive", t, istio_policy_v1beta1.BOOL)
                        }
                    }

                    if param.DoublePrimitive != "" {
                        if t, e := tEvalFn(param.DoublePrimitive); e != nil || t != istio_policy_v1beta1.DOUBLE {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"DoublePrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"DoublePrimitive", t, istio_policy_v1beta1.DOUBLE)
                        }
                    }

                    if param.StringPrimitive != "" {
                        if t, e := tEvalFn(param.StringPrimitive); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"StringPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"StringPrimitive", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    for k, v := range param.DimensionsFixedInt64ValueDType {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "DimensionsFixedInt64ValueDType", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "DimensionsFixedInt64ValueDType", k, t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.TimeStamp != "" {
                        if t, e := tEvalFn(param.TimeStamp); e != nil || t != istio_policy_v1beta1.TIMESTAMP {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"TimeStamp", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"TimeStamp", t, istio_policy_v1beta1.TIMESTAMP)
                        }
                    }

                    if param.Duration != "" {
                        if t, e := tEvalFn(param.Duration); e != nil || t != istio_policy_v1beta1.DURATION {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Duration", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Duration", t, istio_policy_v1beta1.DURATION)
                        }
                    }

                    return nil, err

                }

                instParam := cp.(*istio_mixer_adapter_sample_myapa.InstanceParam)

                const fullOutName = "istio_mixer_adapter_sample_myapa.output."
                for attr, exp := range instParam.AttributeBindings {
                    expr := strings.Replace(exp, "$out.", fullOutName, -1)
                    t1, err := tEvalFn(expr)
                    if err != nil {
                        return nil, fmt.Errorf("error evaluating AttributeBinding expression '%s' for attribute '%s': %v", expr, attr, err)
                    }
                    t2, err := tEvalFn(attr)
                    if err != nil {
                        return nil, fmt.Errorf("error evaluating AttributeBinding expression for attribute key '%s': %v", attr, err)
                    }
                    if t1 != t2 {
                        return nil, fmt.Errorf(
                            "error evaluating AttributeBinding: type '%v' for attribute '%s' does not match type '%s' for expression '%s'",
                            t2, attr, t1, expr)
                    }
                }

                return BuildTemplate(instParam, "")
            },

            AttributeManifests: []*istio_policy_v1beta1.AttributeManifest{
                {
                    Attributes: map[string]*istio_policy_v1beta1.AttributeManifest_AttributeInfo{

                        "istio_mixer_adapter_sample_myapa.output.int64Primitive": {
                            ValueType: istio_policy_v1beta1.INT64,
                        },

                        "istio_mixer_adapter_sample_myapa.output.boolPrimitive": {
                            ValueType: istio_policy_v1beta1.BOOL,
                        },

                        "istio_mixer_adapter_sample_myapa.output.doublePrimitive": {
                            ValueType: istio_policy_v1beta1.DOUBLE,
                        },

                        "istio_mixer_adapter_sample_myapa.output.stringPrimitive": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "istio_mixer_adapter_sample_myapa.output.timeStamp": {
                            ValueType: istio_policy_v1beta1.TIMESTAMP,
                        },

                        "istio_mixer_adapter_sample_myapa.output.duration": {
                            ValueType: istio_policy_v1beta1.DURATION,
                        },

                        "istio_mixer_adapter_sample_myapa.output.email": {
                            ValueType: istio_policy_v1beta1.EMAIL_ADDRESS,
                        },

                        "istio_mixer_adapter_sample_myapa.output.out_ip": {
                            ValueType: istio_policy_v1beta1.IP_ADDRESS,
                        },

                        "istio_mixer_adapter_sample_myapa.output.out_str_map": {
                            ValueType: istio_policy_v1beta1.STRING_MAP,
                        },
                    },
                },
            },

            DispatchGenAttrs: func(ctx context.Context, handler adapter.Handler, inst interface{}, attrs attribute.Bag,
                mapper template.OutputMapperFn) (*attribute.MutableBag, error) {

                instance := inst.(*istio_mixer_adapter_sample_myapa.Instance)

                out, err := handler.(istio_mixer_adapter_sample_myapa.Handler).GenerateMyApaAttributes(ctx, instance)
                if err != nil {
                    return nil, err
                }

                // Construct a wrapper bag around the returned output message and pass it to the output mapper
                // to map $out values back to the destination attributes in the ambient context.
                const fullOutName = "istio_mixer_adapter_sample_myapa.output."
                outBag := newWrapperAttrBag(
                    func(name string) (value interface{}, found bool) {
                        field := strings.TrimPrefix(name, fullOutName)
                        if len(field) != len(name) {
                            if !out.WasSet(field) {
                                return nil, false
                            }
                            switch field {

                            case "int64Primitive":

                                return out.Int64Primitive, true

                            case "boolPrimitive":

                                return out.BoolPrimitive, true

                            case "doublePrimitive":

                                return out.DoublePrimitive, true

                            case "stringPrimitive":

                                return out.StringPrimitive, true

                            case "timeStamp":

                                return out.TimeStamp, true

                            case "duration":

                                return out.Duration, true

                            case "email":

                                return string(out.Email), true

                            case "out_ip":

                                return []byte(out.OutIp), true

                            case "out_str_map":

                                return attribute.WrapStringMap(out.OutStrMap), true

                            default:
                                return nil, false
                            }
                        }
                        return attrs.Get(name)
                    },
                    func() []string { return attrs.Names() },
                    func() { attrs.Done() },
                    func() string { return attrs.String() },
                )

                return mapper(outBag)
            },

            CreateInstanceBuilder: func(instanceName string, param proto.Message, expb lang.Compiler) (template.InstanceBuilderFn, error) {

                if param == nil {
                    return func(attr attribute.Bag) (interface{}, error) {
                        return nil, nil
                    }, nil
                }

                builder, errp := newBuilder_istio_mixer_adapter_sample_myapa_Template(expb, param.(*istio_mixer_adapter_sample_myapa.InstanceParam))
                if !errp.IsNil() {
                    return nil, errp.AsCompilationError(instanceName)
                }

                return func(attr attribute.Bag) (interface{}, error) {

                    e, errp := builder.build(attr)
                    if !errp.IsNil() {
                        err := errp.AsEvaluationError(instanceName)
                        log.Error(err.Error())
                        return nil, err
                    }

                    e.Name = instanceName
                    return e, nil
                }, nil
            },

            CreateOutputExpressions: func(
                instanceParam proto.Message,
                finder attribute.AttributeDescriptorFinder,
                expb lang.Compiler) (map[string]compiled.Expression, error) {
                var err error
                var expType istio_policy_v1beta1.ValueType

                param := instanceParam.(*istio_mixer_adapter_sample_myapa.InstanceParam)

                expressions := make(map[string]compiled.Expression, len(param.AttributeBindings))

                const fullOutName = "istio_mixer_adapter_sample_myapa.output."
                for attrName, outExpr := range param.AttributeBindings {
                    attrInfo := finder.GetAttribute(attrName)
                    if attrInfo == nil {
                        log.Warnf("attribute not found when mapping outputs: attr='%s', expr='%s'", attrName, outExpr)
                        continue
                    }

                    ex := strings.Replace(outExpr, "$out.", fullOutName, -1)

                    if expressions[attrName], expType, err = expb.Compile(ex); err != nil {
                        return nil, err
                    }

                    if attrInfo.ValueType != expType {
                        log.Warnf("attribute type mismatch: attr='%s', attrType='%v', expr='%s', exprType='%v'", attrName, attrInfo.ValueType, outExpr, expType)
                        continue
                    }
                }

                return expressions, nil
            },
        },

        istio_mixer_adapter_sample_check.TemplateName: {
            Name:               istio_mixer_adapter_sample_check.TemplateName,
            Impl:               "istio.mixer.adapter.sample.check",
            CtrCfg:             &istio_mixer_adapter_sample_check.InstanceParam{},
            Variety:            istio_adapter_model_v1beta1.TEMPLATE_VARIETY_CHECK,
            BldrInterfaceName:  istio_mixer_adapter_sample_check.TemplateName + "." + "HandlerBuilder",
            HndlrInterfaceName: istio_mixer_adapter_sample_check.TemplateName + "." + "Handler",
            BuilderSupportsTemplate: func(hndlrBuilder adapter.HandlerBuilder) bool {
                _, ok := hndlrBuilder.(istio_mixer_adapter_sample_check.HandlerBuilder)
                return ok
            },
            HandlerSupportsTemplate: func(hndlr adapter.Handler) bool {
                _, ok := hndlr.(istio_mixer_adapter_sample_check.Handler)
                return ok
            },
            InferType: func(cp proto.Message, tEvalFn template.TypeEvalFn) (proto.Message, error) {

                var BuildTemplate func(param *istio_mixer_adapter_sample_check.InstanceParam,
                    path string) (*istio_mixer_adapter_sample_check.Type, error)

                _ = BuildTemplate

                var BuildRes1 func(param *istio_mixer_adapter_sample_check.Res1InstanceParam,
                    path string) (*istio_mixer_adapter_sample_check.Res1Type, error)

                _ = BuildRes1

                var BuildRes2 func(param *istio_mixer_adapter_sample_check.Res2InstanceParam,
                    path string) (*istio_mixer_adapter_sample_check.Res2Type, error)

                _ = BuildRes2

                BuildTemplate = func(param *istio_mixer_adapter_sample_check.InstanceParam,
                    path string) (*istio_mixer_adapter_sample_check.Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_check.Type{}

                    var err error = nil

                    if param.CheckExpression != "" {
                        if t, e := tEvalFn(param.CheckExpression); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"CheckExpression", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"CheckExpression", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    for k, v := range param.StringMap {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "StringMap", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "StringMap", k, t, istio_policy_v1beta1.STRING)
                        }
                    }

                    if param.Res1 != nil {

                        if infrdType.Res1, err = BuildRes1(param.Res1, path+"Res1."); err != nil {
                            return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Res1", err)
                        }
                    }

                    return infrdType, err

                }

                BuildRes1 = func(param *istio_mixer_adapter_sample_check.Res1InstanceParam,
                    path string) (*istio_mixer_adapter_sample_check.Res1Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_check.Res1Type{}

                    var err error = nil

                    if param.Value == "" {
                        infrdType.Value = istio_policy_v1beta1.VALUE_TYPE_UNSPECIFIED
                    } else if infrdType.Value, err = tEvalFn(param.Value); err != nil {
                        return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Value", err)
                    }

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.BoolPrimitive != "" {
                        if t, e := tEvalFn(param.BoolPrimitive); e != nil || t != istio_policy_v1beta1.BOOL {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"BoolPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"BoolPrimitive", t, istio_policy_v1beta1.BOOL)
                        }
                    }

                    if param.DoublePrimitive != "" {
                        if t, e := tEvalFn(param.DoublePrimitive); e != nil || t != istio_policy_v1beta1.DOUBLE {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"DoublePrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"DoublePrimitive", t, istio_policy_v1beta1.DOUBLE)
                        }
                    }

                    if param.StringPrimitive != "" {
                        if t, e := tEvalFn(param.StringPrimitive); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"StringPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"StringPrimitive", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    for k, v := range param.Int64Map {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Int64Map", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "Int64Map", k, t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.TimeStamp != "" {
                        if t, e := tEvalFn(param.TimeStamp); e != nil || t != istio_policy_v1beta1.TIMESTAMP {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"TimeStamp", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"TimeStamp", t, istio_policy_v1beta1.TIMESTAMP)
                        }
                    }

                    if param.Duration != "" {
                        if t, e := tEvalFn(param.Duration); e != nil || t != istio_policy_v1beta1.DURATION {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Duration", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Duration", t, istio_policy_v1beta1.DURATION)
                        }
                    }

                    if param.Res2 != nil {

                        if infrdType.Res2, err = BuildRes2(param.Res2, path+"Res2."); err != nil {
                            return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Res2", err)
                        }
                    }

                    infrdType.Res2Map = make(map[string]*istio_mixer_adapter_sample_check.Res2Type, len(param.Res2Map))

                    for k, v := range param.Res2Map {

                        if infrdType.Res2Map[k], err = BuildRes2(v, path+"Res2Map["+k+"]."); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Res2Map", k, err)
                        }
                    }

                    return infrdType, err

                }

                BuildRes2 = func(param *istio_mixer_adapter_sample_check.Res2InstanceParam,
                    path string) (*istio_mixer_adapter_sample_check.Res2Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_check.Res2Type{}

                    var err error = nil

                    if param.Value == "" {
                        infrdType.Value = istio_policy_v1beta1.VALUE_TYPE_UNSPECIFIED
                    } else if infrdType.Value, err = tEvalFn(param.Value); err != nil {
                        return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Value", err)
                    }

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    return infrdType, err

                }

                instParam := cp.(*istio_mixer_adapter_sample_check.InstanceParam)

                return BuildTemplate(instParam, "")
            },

            SetType: func(types map[string]proto.Message, builder adapter.HandlerBuilder) {

                castedBuilder := builder.(istio_mixer_adapter_sample_check.HandlerBuilder)
                castedTypes := make(map[string]*istio_mixer_adapter_sample_check.Type, len(types))
                for k, v := range types {

                    v1 := v.(*istio_mixer_adapter_sample_check.Type)
                    castedTypes[k] = v1
                }
                castedBuilder.SetCheckTypes(castedTypes)
            },

            DispatchCheck: func(ctx context.Context, handler adapter.Handler, inst interface{}, out *attribute.MutableBag, outPrefix string) (adapter.CheckResult, error) {

                instance := inst.(*istio_mixer_adapter_sample_check.Instance)

                return handler.(istio_mixer_adapter_sample_check.Handler).HandleCheck(ctx, instance)
            },

            CreateInstanceBuilder: func(instanceName string, param proto.Message, expb lang.Compiler) (template.InstanceBuilderFn, error) {

                if param == nil {
                    return func(attr attribute.Bag) (interface{}, error) {
                        return nil, nil
                    }, nil
                }

                builder, errp := newBuilder_istio_mixer_adapter_sample_check_Template(expb, param.(*istio_mixer_adapter_sample_check.InstanceParam))
                if !errp.IsNil() {
                    return nil, errp.AsCompilationError(instanceName)
                }

                return func(attr attribute.Bag) (interface{}, error) {

                    e, errp := builder.build(attr)
                    if !errp.IsNil() {
                        err := errp.AsEvaluationError(instanceName)
                        log.Error(err.Error())
                        return nil, err
                    }

                    e.Name = instanceName
                    return e, nil
                }, nil
            },
        },

        istio_mixer_adapter_sample_quota.TemplateName: {
            Name:               istio_mixer_adapter_sample_quota.TemplateName,
            Impl:               "istio.mixer.adapter.sample.quota",
            CtrCfg:             &istio_mixer_adapter_sample_quota.InstanceParam{},
            Variety:            istio_adapter_model_v1beta1.TEMPLATE_VARIETY_QUOTA,
            BldrInterfaceName:  istio_mixer_adapter_sample_quota.TemplateName + "." + "HandlerBuilder",
            HndlrInterfaceName: istio_mixer_adapter_sample_quota.TemplateName + "." + "Handler",
            BuilderSupportsTemplate: func(hndlrBuilder adapter.HandlerBuilder) bool {
                _, ok := hndlrBuilder.(istio_mixer_adapter_sample_quota.HandlerBuilder)
                return ok
            },
            HandlerSupportsTemplate: func(hndlr adapter.Handler) bool {
                _, ok := hndlr.(istio_mixer_adapter_sample_quota.Handler)
                return ok
            },
            InferType: func(cp proto.Message, tEvalFn template.TypeEvalFn) (proto.Message, error) {

                var BuildTemplate func(param *istio_mixer_adapter_sample_quota.InstanceParam,
                    path string) (*istio_mixer_adapter_sample_quota.Type, error)

                _ = BuildTemplate

                var BuildRes1 func(param *istio_mixer_adapter_sample_quota.Res1InstanceParam,
                    path string) (*istio_mixer_adapter_sample_quota.Res1Type, error)

                _ = BuildRes1

                var BuildRes2 func(param *istio_mixer_adapter_sample_quota.Res2InstanceParam,
                    path string) (*istio_mixer_adapter_sample_quota.Res2Type, error)

                _ = BuildRes2

                BuildTemplate = func(param *istio_mixer_adapter_sample_quota.InstanceParam,
                    path string) (*istio_mixer_adapter_sample_quota.Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_quota.Type{}

                    var err error = nil

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    for k, v := range param.BoolMap {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.BOOL {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "BoolMap", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "BoolMap", k, t, istio_policy_v1beta1.BOOL)
                        }
                    }

                    if param.Res1 != nil {

                        if infrdType.Res1, err = BuildRes1(param.Res1, path+"Res1."); err != nil {
                            return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Res1", err)
                        }
                    }

                    return infrdType, err

                }

                BuildRes1 = func(param *istio_mixer_adapter_sample_quota.Res1InstanceParam,
                    path string) (*istio_mixer_adapter_sample_quota.Res1Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_quota.Res1Type{}

                    var err error = nil

                    if param.Value == "" {
                        infrdType.Value = istio_policy_v1beta1.VALUE_TYPE_UNSPECIFIED
                    } else if infrdType.Value, err = tEvalFn(param.Value); err != nil {
                        return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Value", err)
                    }

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.BoolPrimitive != "" {
                        if t, e := tEvalFn(param.BoolPrimitive); e != nil || t != istio_policy_v1beta1.BOOL {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"BoolPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"BoolPrimitive", t, istio_policy_v1beta1.BOOL)
                        }
                    }

                    if param.DoublePrimitive != "" {
                        if t, e := tEvalFn(param.DoublePrimitive); e != nil || t != istio_policy_v1beta1.DOUBLE {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"DoublePrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"DoublePrimitive", t, istio_policy_v1beta1.DOUBLE)
                        }
                    }

                    if param.StringPrimitive != "" {
                        if t, e := tEvalFn(param.StringPrimitive); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"StringPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"StringPrimitive", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    for k, v := range param.Int64Map {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Int64Map", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "Int64Map", k, t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.TimeStamp != "" {
                        if t, e := tEvalFn(param.TimeStamp); e != nil || t != istio_policy_v1beta1.TIMESTAMP {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"TimeStamp", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"TimeStamp", t, istio_policy_v1beta1.TIMESTAMP)
                        }
                    }

                    if param.Duration != "" {
                        if t, e := tEvalFn(param.Duration); e != nil || t != istio_policy_v1beta1.DURATION {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Duration", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Duration", t, istio_policy_v1beta1.DURATION)
                        }
                    }

                    if param.Res2 != nil {

                        if infrdType.Res2, err = BuildRes2(param.Res2, path+"Res2."); err != nil {
                            return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Res2", err)
                        }
                    }

                    infrdType.Res2Map = make(map[string]*istio_mixer_adapter_sample_quota.Res2Type, len(param.Res2Map))

                    for k, v := range param.Res2Map {

                        if infrdType.Res2Map[k], err = BuildRes2(v, path+"Res2Map["+k+"]."); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Res2Map", k, err)
                        }
                    }

                    return infrdType, err

                }

                BuildRes2 = func(param *istio_mixer_adapter_sample_quota.Res2InstanceParam,
                    path string) (*istio_mixer_adapter_sample_quota.Res2Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_quota.Res2Type{}

                    var err error = nil

                    if param.Value == "" {
                        infrdType.Value = istio_policy_v1beta1.VALUE_TYPE_UNSPECIFIED
                    } else if infrdType.Value, err = tEvalFn(param.Value); err != nil {
                        return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Value", err)
                    }

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    return infrdType, err

                }

                instParam := cp.(*istio_mixer_adapter_sample_quota.InstanceParam)

                return BuildTemplate(instParam, "")
            },

            SetType: func(types map[string]proto.Message, builder adapter.HandlerBuilder) {

                castedBuilder := builder.(istio_mixer_adapter_sample_quota.HandlerBuilder)
                castedTypes := make(map[string]*istio_mixer_adapter_sample_quota.Type, len(types))
                for k, v := range types {

                    v1 := v.(*istio_mixer_adapter_sample_quota.Type)
                    castedTypes[k] = v1
                }
                castedBuilder.SetQuotaTypes(castedTypes)
            },

            DispatchQuota: func(ctx context.Context, handler adapter.Handler, inst interface{}, args adapter.QuotaArgs) (adapter.QuotaResult, error) {

                instance := inst.(*istio_mixer_adapter_sample_quota.Instance)

                return handler.(istio_mixer_adapter_sample_quota.Handler).HandleQuota(ctx, instance, args)
            },

            CreateInstanceBuilder: func(instanceName string, param proto.Message, expb lang.Compiler) (template.InstanceBuilderFn, error) {

                if param == nil {
                    return func(attr attribute.Bag) (interface{}, error) {
                        return nil, nil
                    }, nil
                }

                builder, errp := newBuilder_istio_mixer_adapter_sample_quota_Template(expb, param.(*istio_mixer_adapter_sample_quota.InstanceParam))
                if !errp.IsNil() {
                    return nil, errp.AsCompilationError(instanceName)
                }

                return func(attr attribute.Bag) (interface{}, error) {

                    e, errp := builder.build(attr)
                    if !errp.IsNil() {
                        err := errp.AsEvaluationError(instanceName)
                        log.Error(err.Error())
                        return nil, err
                    }

                    e.Name = instanceName
                    return e, nil
                }, nil
            },
        },

        istio_mixer_adapter_sample_report.TemplateName: {
            Name:               istio_mixer_adapter_sample_report.TemplateName,
            Impl:               "istio.mixer.adapter.sample.report",
            CtrCfg:             &istio_mixer_adapter_sample_report.InstanceParam{},
            Variety:            istio_adapter_model_v1beta1.TEMPLATE_VARIETY_REPORT,
            BldrInterfaceName:  istio_mixer_adapter_sample_report.TemplateName + "." + "HandlerBuilder",
            HndlrInterfaceName: istio_mixer_adapter_sample_report.TemplateName + "." + "Handler",
            BuilderSupportsTemplate: func(hndlrBuilder adapter.HandlerBuilder) bool {
                _, ok := hndlrBuilder.(istio_mixer_adapter_sample_report.HandlerBuilder)
                return ok
            },
            HandlerSupportsTemplate: func(hndlr adapter.Handler) bool {
                _, ok := hndlr.(istio_mixer_adapter_sample_report.Handler)
                return ok
            },
            InferType: func(cp proto.Message, tEvalFn template.TypeEvalFn) (proto.Message, error) {

                var BuildTemplate func(param *istio_mixer_adapter_sample_report.InstanceParam,
                    path string) (*istio_mixer_adapter_sample_report.Type, error)

                _ = BuildTemplate

                var BuildRes1 func(param *istio_mixer_adapter_sample_report.Res1InstanceParam,
                    path string) (*istio_mixer_adapter_sample_report.Res1Type, error)

                _ = BuildRes1

                var BuildRes2 func(param *istio_mixer_adapter_sample_report.Res2InstanceParam,
                    path string) (*istio_mixer_adapter_sample_report.Res2Type, error)

                _ = BuildRes2

                BuildTemplate = func(param *istio_mixer_adapter_sample_report.InstanceParam,
                    path string) (*istio_mixer_adapter_sample_report.Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_report.Type{}

                    var err error = nil

                    if param.Value == "" {
                        infrdType.Value = istio_policy_v1beta1.VALUE_TYPE_UNSPECIFIED
                    } else if infrdType.Value, err = tEvalFn(param.Value); err != nil {
                        return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Value", err)
                    }

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.BoolPrimitive != "" {
                        if t, e := tEvalFn(param.BoolPrimitive); e != nil || t != istio_policy_v1beta1.BOOL {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"BoolPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"BoolPrimitive", t, istio_policy_v1beta1.BOOL)
                        }
                    }

                    if param.DoublePrimitive != "" {
                        if t, e := tEvalFn(param.DoublePrimitive); e != nil || t != istio_policy_v1beta1.DOUBLE {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"DoublePrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"DoublePrimitive", t, istio_policy_v1beta1.DOUBLE)
                        }
                    }

                    if param.StringPrimitive != "" {
                        if t, e := tEvalFn(param.StringPrimitive); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"StringPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"StringPrimitive", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    for k, v := range param.Int64Map {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Int64Map", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "Int64Map", k, t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.TimeStamp != "" {
                        if t, e := tEvalFn(param.TimeStamp); e != nil || t != istio_policy_v1beta1.TIMESTAMP {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"TimeStamp", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"TimeStamp", t, istio_policy_v1beta1.TIMESTAMP)
                        }
                    }

                    if param.Duration != "" {
                        if t, e := tEvalFn(param.Duration); e != nil || t != istio_policy_v1beta1.DURATION {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Duration", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Duration", t, istio_policy_v1beta1.DURATION)
                        }
                    }

                    if param.Res1 != nil {

                        if infrdType.Res1, err = BuildRes1(param.Res1, path+"Res1."); err != nil {
                            return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Res1", err)
                        }
                    }

                    return infrdType, err

                }

                BuildRes1 = func(param *istio_mixer_adapter_sample_report.Res1InstanceParam,
                    path string) (*istio_mixer_adapter_sample_report.Res1Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_report.Res1Type{}

                    var err error = nil

                    if param.Value == "" {
                        infrdType.Value = istio_policy_v1beta1.VALUE_TYPE_UNSPECIFIED
                    } else if infrdType.Value, err = tEvalFn(param.Value); err != nil {
                        return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Value", err)
                    }

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.BoolPrimitive != "" {
                        if t, e := tEvalFn(param.BoolPrimitive); e != nil || t != istio_policy_v1beta1.BOOL {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"BoolPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"BoolPrimitive", t, istio_policy_v1beta1.BOOL)
                        }
                    }

                    if param.DoublePrimitive != "" {
                        if t, e := tEvalFn(param.DoublePrimitive); e != nil || t != istio_policy_v1beta1.DOUBLE {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"DoublePrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"DoublePrimitive", t, istio_policy_v1beta1.DOUBLE)
                        }
                    }

                    if param.StringPrimitive != "" {
                        if t, e := tEvalFn(param.StringPrimitive); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"StringPrimitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"StringPrimitive", t, istio_policy_v1beta1.STRING)
                        }
                    }

                    for k, v := range param.Int64Map {
                        if t, e := tEvalFn(v); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Int64Map", k, e)
                            }
                            return nil, fmt.Errorf(
                                "error type checking for field '%s%s[%s]': Evaluated expression type %v want %v", path, "Int64Map", k, t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.TimeStamp != "" {
                        if t, e := tEvalFn(param.TimeStamp); e != nil || t != istio_policy_v1beta1.TIMESTAMP {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"TimeStamp", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"TimeStamp", t, istio_policy_v1beta1.TIMESTAMP)
                        }
                    }

                    if param.Duration != "" {
                        if t, e := tEvalFn(param.Duration); e != nil || t != istio_policy_v1beta1.DURATION {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Duration", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Duration", t, istio_policy_v1beta1.DURATION)
                        }
                    }

                    if param.Res2 != nil {

                        if infrdType.Res2, err = BuildRes2(param.Res2, path+"Res2."); err != nil {
                            return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Res2", err)
                        }
                    }

                    infrdType.Res2Map = make(map[string]*istio_mixer_adapter_sample_report.Res2Type, len(param.Res2Map))

                    for k, v := range param.Res2Map {

                        if infrdType.Res2Map[k], err = BuildRes2(v, path+"Res2Map["+k+"]."); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Res2Map", k, err)
                        }
                    }

                    return infrdType, err

                }

                BuildRes2 = func(param *istio_mixer_adapter_sample_report.Res2InstanceParam,
                    path string) (*istio_mixer_adapter_sample_report.Res2Type, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &istio_mixer_adapter_sample_report.Res2Type{}

                    var err error = nil

                    if param.Value == "" {
                        infrdType.Value = istio_policy_v1beta1.VALUE_TYPE_UNSPECIFIED
                    } else if infrdType.Value, err = tEvalFn(param.Value); err != nil {
                        return nil, fmt.Errorf("failed to evaluate expression for field '%s'; %v", path+"Value", err)
                    }

                    infrdType.Dimensions = make(map[string]istio_policy_v1beta1.ValueType, len(param.Dimensions))

                    for k, v := range param.Dimensions {

                        if infrdType.Dimensions[k], err = tEvalFn(v); err != nil {

                            return nil, fmt.Errorf("failed to evaluate expression for field '%s%s[%s]'; %v", path, "Dimensions", k, err)
                        }
                    }

                    if param.Int64Primitive != "" {
                        if t, e := tEvalFn(param.Int64Primitive); e != nil || t != istio_policy_v1beta1.INT64 {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Int64Primitive", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Int64Primitive", t, istio_policy_v1beta1.INT64)
                        }
                    }

                    if param.TimeStamp != "" {
                        if t, e := tEvalFn(param.TimeStamp); e != nil || t != istio_policy_v1beta1.TIMESTAMP {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"TimeStamp", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"TimeStamp", t, istio_policy_v1beta1.TIMESTAMP)
                        }
                    }

                    if param.Duration != "" {
                        if t, e := tEvalFn(param.Duration); e != nil || t != istio_policy_v1beta1.DURATION {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Duration", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Duration", t, istio_policy_v1beta1.DURATION)
                        }
                    }

                    if param.IpAddr != "" {
                        if t, e := tEvalFn(param.IpAddr); e != nil || t != istio_policy_v1beta1.IP_ADDRESS {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"IpAddr", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"IpAddr", t, istio_policy_v1beta1.IP_ADDRESS)
                        }
                    }

                    if param.DnsName != "" {
                        if t, e := tEvalFn(param.DnsName); e != nil || t != istio_policy_v1beta1.DNS_NAME {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"DnsName", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"DnsName", t, istio_policy_v1beta1.DNS_NAME)
                        }
                    }

                    if param.EmailAddr != "" {
                        if t, e := tEvalFn(param.EmailAddr); e != nil || t != istio_policy_v1beta1.EMAIL_ADDRESS {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"EmailAddr", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"EmailAddr", t, istio_policy_v1beta1.EMAIL_ADDRESS)
                        }
                    }

                    if param.Uri != "" {
                        if t, e := tEvalFn(param.Uri); e != nil || t != istio_policy_v1beta1.URI {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"Uri", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"Uri", t, istio_policy_v1beta1.URI)
                        }
                    }

                    return infrdType, err

                }

                instParam := cp.(*istio_mixer_adapter_sample_report.InstanceParam)

                return BuildTemplate(instParam, "")
            },

            SetType: func(types map[string]proto.Message, builder adapter.HandlerBuilder) {

                castedBuilder := builder.(istio_mixer_adapter_sample_report.HandlerBuilder)
                castedTypes := make(map[string]*istio_mixer_adapter_sample_report.Type, len(types))
                for k, v := range types {

                    v1 := v.(*istio_mixer_adapter_sample_report.Type)
                    castedTypes[k] = v1
                }
                castedBuilder.SetReportTypes(castedTypes)
            },

            DispatchReport: func(ctx context.Context, handler adapter.Handler, inst []interface{}) error {

                instances := make([]*istio_mixer_adapter_sample_report.Instance, len(inst))
                for i, instance := range inst {
                    instances[i] = instance.(*istio_mixer_adapter_sample_report.Instance)
                }

                if err := handler.(istio_mixer_adapter_sample_report.Handler).HandleReport(ctx, instances); err != nil {
                    return fmt.Errorf("failed to report all values: %v", err)
                }
                return nil
            },

            CreateInstanceBuilder: func(instanceName string, param proto.Message, expb lang.Compiler) (template.InstanceBuilderFn, error) {

                if param == nil {
                    return func(attr attribute.Bag) (interface{}, error) {
                        return nil, nil
                    }, nil
                }

                builder, errp := newBuilder_istio_mixer_adapter_sample_report_Template(expb, param.(*istio_mixer_adapter_sample_report.InstanceParam))
                if !errp.IsNil() {
                    return nil, errp.AsCompilationError(instanceName)
                }

                return func(attr attribute.Bag) (interface{}, error) {

                    e, errp := builder.build(attr)
                    if !errp.IsNil() {
                        err := errp.AsEvaluationError(instanceName)
                        log.Error(err.Error())
                        return nil, err
                    }

                    e.Name = instanceName
                    return e, nil
                }, nil
            },
        },
    }
)

Directories

PathSynopsis
apa
check
quota
report

Package sample imports 18 packages (graph). Updated 2019-11-16. Refresh now. Tools for package owners.