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

package template

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

Package template provides runtime descriptors of the templates known to Mixer at compile-time.

Index

Package Files

doc.go template.gen.go

Variables

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

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    var err error = nil

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

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

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

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

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

                    return nil, err

                }

                instParam := cp.(*adapter_template_kubernetes.InstanceParam)

                const fullOutName = "adapter_template_kubernetes.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{

                        "adapter_template_kubernetes.output.source_pod_uid": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.source_pod_ip": {
                            ValueType: istio_policy_v1beta1.IP_ADDRESS,
                        },

                        "adapter_template_kubernetes.output.source_pod_name": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.source_labels": {
                            ValueType: istio_policy_v1beta1.STRING_MAP,
                        },

                        "adapter_template_kubernetes.output.source_namespace": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.source_service_account_name": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.source_host_ip": {
                            ValueType: istio_policy_v1beta1.IP_ADDRESS,
                        },

                        "adapter_template_kubernetes.output.source_workload_uid": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.source_workload_name": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.source_workload_namespace": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.source_owner": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_pod_uid": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_pod_ip": {
                            ValueType: istio_policy_v1beta1.IP_ADDRESS,
                        },

                        "adapter_template_kubernetes.output.destination_pod_name": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_container_name": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_labels": {
                            ValueType: istio_policy_v1beta1.STRING_MAP,
                        },

                        "adapter_template_kubernetes.output.destination_namespace": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_service_account_name": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_host_ip": {
                            ValueType: istio_policy_v1beta1.IP_ADDRESS,
                        },

                        "adapter_template_kubernetes.output.destination_owner": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_workload_uid": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_workload_name": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },

                        "adapter_template_kubernetes.output.destination_workload_namespace": {
                            ValueType: istio_policy_v1beta1.STRING,
                        },
                    },
                },
            },

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

                instance := inst.(*adapter_template_kubernetes.Instance)

                out, err := handler.(adapter_template_kubernetes.Handler).GenerateKubernetesAttributes(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 = "adapter_template_kubernetes.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 "source_pod_uid":

                                return out.SourcePodUid, true

                            case "source_pod_ip":

                                return []byte(out.SourcePodIp), true

                            case "source_pod_name":

                                return out.SourcePodName, true

                            case "source_labels":

                                return attribute.WrapStringMap(out.SourceLabels), true

                            case "source_namespace":

                                return out.SourceNamespace, true

                            case "source_service_account_name":

                                return out.SourceServiceAccountName, true

                            case "source_host_ip":

                                return []byte(out.SourceHostIp), true

                            case "source_workload_uid":

                                return out.SourceWorkloadUid, true

                            case "source_workload_name":

                                return out.SourceWorkloadName, true

                            case "source_workload_namespace":

                                return out.SourceWorkloadNamespace, true

                            case "source_owner":

                                return out.SourceOwner, true

                            case "destination_pod_uid":

                                return out.DestinationPodUid, true

                            case "destination_pod_ip":

                                return []byte(out.DestinationPodIp), true

                            case "destination_pod_name":

                                return out.DestinationPodName, true

                            case "destination_container_name":

                                return out.DestinationContainerName, true

                            case "destination_labels":

                                return attribute.WrapStringMap(out.DestinationLabels), true

                            case "destination_namespace":

                                return out.DestinationNamespace, true

                            case "destination_service_account_name":

                                return out.DestinationServiceAccountName, true

                            case "destination_host_ip":

                                return []byte(out.DestinationHostIp), true

                            case "destination_owner":

                                return out.DestinationOwner, true

                            case "destination_workload_uid":

                                return out.DestinationWorkloadUid, true

                            case "destination_workload_name":

                                return out.DestinationWorkloadName, true

                            case "destination_workload_namespace":

                                return out.DestinationWorkloadNamespace, 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_adapter_template_kubernetes_Template(expb, param.(*adapter_template_kubernetes.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.(*adapter_template_kubernetes.InstanceParam)

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

                const fullOutName = "adapter_template_kubernetes.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &apikey.Type{}

                    var err error = nil

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

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

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

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

                    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)
                        }
                    }

                    return infrdType, err

                }

                instParam := cp.(*apikey.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

                instance := inst.(*apikey.Instance)

                return handler.(apikey.Handler).HandleApiKey(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_apikey_Template(expb, param.(*apikey.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
            },
        },

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

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

                _ = BuildTemplate

                var BuildSubject func(param *authorization.SubjectInstanceParam,
                    path string) (*authorization.SubjectType, error)

                _ = BuildSubject

                var BuildAction func(param *authorization.ActionInstanceParam,
                    path string) (*authorization.ActionType, error)

                _ = BuildAction

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &authorization.Type{}

                    var err error = nil

                    if param.Subject != nil {

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

                    if param.Action != nil {

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

                    return infrdType, err

                }

                BuildSubject = func(param *authorization.SubjectInstanceParam,
                    path string) (*authorization.SubjectType, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &authorization.SubjectType{}

                    var err error = nil

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

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

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

                    for k, v := range param.Properties {

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

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

                    return infrdType, err

                }

                BuildAction = func(param *authorization.ActionInstanceParam,
                    path string) (*authorization.ActionType, error) {

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &authorization.ActionType{}

                    var err error = nil

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

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

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

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

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

                    for k, v := range param.Properties {

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

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

                    return infrdType, err

                }

                instParam := cp.(*authorization.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

                instance := inst.(*authorization.Instance)

                return handler.(authorization.Handler).HandleAuthorization(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_authorization_Template(expb, param.(*authorization.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &checknothing.Type{}

                    var err error = nil

                    return infrdType, err

                }

                instParam := cp.(*checknothing.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

                instance := inst.(*checknothing.Instance)

                return handler.(checknothing.Handler).HandleCheckNothing(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_checknothing_Template(expb, param.(*checknothing.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &edge.Type{}

                    var err error = nil

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

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

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

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

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

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

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

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

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

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

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

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

                    return infrdType, err

                }

                instParam := cp.(*edge.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

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

                if err := handler.(edge.Handler).HandleEdge(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_edge_Template(expb, param.(*edge.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &listentry.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)
                    }

                    return infrdType, err

                }

                instParam := cp.(*listentry.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

                instance := inst.(*listentry.Instance)

                return handler.(listentry.Handler).HandleListEntry(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_listentry_Template(expb, param.(*listentry.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &logentry.Type{}

                    var err error = nil

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

                    for k, v := range param.Variables {

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

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

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

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

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

                    for k, v := range param.MonitoredResourceDimensions {

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

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

                    return infrdType, err

                }

                instParam := cp.(*logentry.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

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

                if err := handler.(logentry.Handler).HandleLogEntry(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_logentry_Template(expb, param.(*logentry.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &metric.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.MonitoredResourceType != "" {
                        if t, e := tEvalFn(param.MonitoredResourceType); e != nil || t != istio_policy_v1beta1.STRING {
                            if e != nil {
                                return nil, fmt.Errorf("failed to evaluate expression for field '%s': %v", path+"MonitoredResourceType", e)
                            }
                            return nil, fmt.Errorf("error type checking for field '%s': Evaluated expression type %v want %v", path+"MonitoredResourceType", t, istio_policy_v1beta1.STRING)
                        }
                    }

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

                    for k, v := range param.MonitoredResourceDimensions {

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

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

                    return infrdType, err

                }

                instParam := cp.(*metric.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

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

                if err := handler.(metric.Handler).HandleMetric(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_metric_Template(expb, param.(*metric.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &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)
                        }
                    }

                    return infrdType, err

                }

                instParam := cp.(*quota.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

                    v1 := v.(*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.(*quota.Instance)

                return handler.(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_quota_Template(expb, param.(*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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &reportnothing.Type{}

                    var err error = nil

                    return infrdType, err

                }

                instParam := cp.(*reportnothing.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

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

                if err := handler.(reportnothing.Handler).HandleReportNothing(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_reportnothing_Template(expb, param.(*reportnothing.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
            },
        },

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

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

                _ = BuildTemplate

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

                    if param == nil {
                        return nil, nil
                    }

                    infrdType := &tracespan.Type{}

                    var err error = nil

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

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

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

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

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

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

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

                    for k, v := range param.SpanTags {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    return infrdType, err

                }

                instParam := cp.(*tracespan.InstanceParam)

                return BuildTemplate(instParam, "")
            },

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

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

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

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

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

                if err := handler.(tracespan.Handler).HandleTraceSpan(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_tracespan_Template(expb, param.(*tracespan.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
apikey
authorization
checknothing
edge
listentry
logentry
metric
quota
reportnothing
samplePackage sample provides a set of templates for internal testing of Mixer.
sample/apa
sample/check
sample/quota
sample/report
tracespan

Package template imports 25 packages (graph) and is imported by 6 packages. Updated 2019-10-15. Refresh now. Tools for package owners.