...

Text file src/github.com/linkerd/linkerd2/charts/linkerd-crds/templates/policy/httproute.yaml

Documentation: github.com/linkerd/linkerd2/charts/linkerd-crds/templates/policy

     1---
     2apiVersion: apiextensions.k8s.io/v1
     3kind: CustomResourceDefinition
     4metadata:
     5  name: httproutes.policy.linkerd.io
     6  annotations:
     7    {{ include "partials.annotations.created-by" . }}
     8  labels:
     9    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
    10    linkerd.io/control-plane-ns: {{.Release.Namespace}}
    11spec:
    12  group: policy.linkerd.io
    13  names:
    14    kind: HTTPRoute
    15    listKind: HTTPRouteList
    16    plural: httproutes
    17    singular: httproute
    18  scope: Namespaced
    19  versions:
    20  - additionalPrinterColumns:
    21    - jsonPath: .spec.hostnames
    22      name: Hostnames
    23      type: string
    24    - jsonPath: .metadata.creationTimestamp
    25      name: Age
    26      type: date
    27    name: v1alpha1
    28    schema:
    29      openAPIV3Schema:
    30        description: HTTPRoute provides a way to route HTTP requests. This includes
    31          the capability to match requests by hostname, path, header, or query param.
    32          Filters can be used to specify additional processing steps. Backends specify
    33          where matching requests should be routed.
    34        properties:
    35          apiVersion:
    36            description: 'APIVersion defines the versioned schema of this representation
    37              of an object. Servers should convert recognized schemas to the latest
    38              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
    39            type: string
    40          kind:
    41            description: 'Kind is a string value representing the REST resource this
    42              object represents. Servers may infer this from the endpoint the client
    43              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
    44            type: string
    45          metadata:
    46            type: object
    47          spec:
    48            description: Spec defines the desired state of HTTPRoute.
    49            properties:
    50              hostnames:
    51                description: "Hostnames defines a set of hostname that should match
    52                  against the HTTP Host header to select a HTTPRoute to process the
    53                  request. This matches the RFC 1123 definition of a hostname with
    54                  2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname may
    55                  be prefixed with a wildcard label (`*.`). The wildcard    label
    56                  must appear by itself as the first label. \n If a hostname is specified
    57                  by both the Listener and HTTPRoute, there must be at least one intersecting
    58                  hostname for the HTTPRoute to be attached to the Listener. For example:
    59                  \n * A Listener with `test.example.com` as the hostname matches
    60                  HTTPRoutes   that have either not specified any hostnames, or have
    61                  specified at   least one of `test.example.com` or `*.example.com`.
    62                  * A Listener with `*.example.com` as the hostname matches HTTPRoutes
    63                  \  that have either not specified any hostnames or have specified
    64                  at least   one hostname that matches the Listener hostname. For
    65                  example,   `*.example.com`, `test.example.com`, and `foo.test.example.com`
    66                  would   all match. On the other hand, `example.com` and `test.example.net`
    67                  would   not match. \n Hostnames that are prefixed with a wildcard
    68                  label (`*.`) are interpreted as a suffix match. That means that
    69                  a match for `*.example.com` would match both `test.example.com`,
    70                  and `foo.test.example.com`, but not `example.com`. \n If both the
    71                  Listener and HTTPRoute have specified hostnames, any HTTPRoute hostnames
    72                  that do not match the Listener hostname MUST be ignored. For example,
    73                  if a Listener specified `*.example.com`, and the HTTPRoute specified
    74                  `test.example.com` and `test.example.net`, `test.example.net` must
    75                  not be considered for a match. \n If both the Listener and HTTPRoute
    76                  have specified hostnames, and none match with the criteria above,
    77                  then the HTTPRoute is not accepted. The implementation must raise
    78                  an 'Accepted' Condition with a status of `False` in the corresponding
    79                  RouteParentStatus. \n Support: Core"
    80                items:
    81                  description: "Hostname is the fully qualified domain name of a network
    82                    host. This matches the RFC 1123 definition of a hostname with
    83                    2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
    84                    may be prefixed with a wildcard label (`*.`). The wildcard    label
    85                    must appear by itself as the first label. \n Hostname can be \"precise\"
    86                    which is a domain name without the terminating dot of a network
    87                    host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
    88                    name prefixed with a single wildcard label (e.g. `*.example.com`).
    89                    \n Note that as per RFC1035 and RFC1123, a *label* must consist
    90                    of lower case alphanumeric characters or '-', and must start and
    91                    end with an alphanumeric character. No other punctuation is allowed."
    92                  maxLength: 253
    93                  minLength: 1
    94                  pattern: ^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
    95                  type: string
    96                maxItems: 16
    97                type: array
    98              parentRefs:
    99                description: "ParentRefs references the resources (usually Gateways)
   100                  that a Route wants to be attached to. Note that the referenced parent
   101                  resource needs to allow this for the attachment to be complete.
   102                  For Gateways, that means the Gateway needs to allow attachment from
   103                  Routes of this kind and namespace. \n The only kind of parent resource
   104                  with \"Core\" support is Gateway. This API may be extended in the
   105                  future to support additional kinds of parent resources such as one
   106                  of the route kinds. \n It is invalid to reference an identical parent
   107                  more than once. It is valid to reference multiple distinct sections
   108                  within the same parent resource, such as 2 Listeners within a Gateway.
   109                  \n It is possible to separately reference multiple distinct objects
   110                  that may be collapsed by an implementation. For example, some implementations
   111                  may choose to merge compatible Gateway Listeners together. If that
   112                  is the case, the list of routes attached to those resources should
   113                  also be merged."
   114                items:
   115                  description: "ParentReference identifies an API object (usually
   116                    a Gateway) that can be considered a parent of this resource (usually
   117                    a route). The only kind of parent resource with \"Core\" support
   118                    is Gateway. This API may be extended in the future to support
   119                    additional kinds of parent resources, such as HTTPRoute. \n The
   120                    API object must be valid in the cluster; the Group and Kind must
   121                    be registered in the cluster for this reference to be valid."
   122                  properties:
   123                    group:
   124                      default: policy.linkerd.io
   125                      description: "Group is the group of the referent. \n Support:
   126                        Core"
   127                      maxLength: 253
   128                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   129                      type: string
   130                    kind:
   131                      default: Gateway
   132                      description: "Kind is kind of the referent. \n Support: Core
   133                        (Gateway) Support: Custom (Other Resources)"
   134                      maxLength: 63
   135                      minLength: 1
   136                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   137                      type: string
   138                    name:
   139                      description: "Name is the name of the referent. \n Support:
   140                        Core"
   141                      maxLength: 253
   142                      minLength: 1
   143                      type: string
   144                    namespace:
   145                      description: "Namespace is the namespace of the referent. When
   146                        unspecified (or empty string), this refers to the local namespace
   147                        of the Route. \n Support: Core"
   148                      maxLength: 63
   149                      minLength: 1
   150                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   151                      type: string
   152                    port:
   153                      description: "port"
   154                      type: integer
   155                    sectionName:
   156                      description: "SectionName is the name of a section within the
   157                        target resource. In the following resources, SectionName is
   158                        interpreted as the following: \n * Gateway: Listener Name.
   159                        When both Port (experimental) and SectionName are specified,
   160                        the name and port of the selected listener must match both
   161                        specified values. \n Implementations MAY choose to support
   162                        attaching Routes to other resources. If that is the case,
   163                        they MUST clearly document how SectionName is interpreted.
   164                        \n When unspecified (empty string), this will reference the
   165                        entire resource. For the purpose of status, an attachment
   166                        is considered successful if at least one section in the parent
   167                        resource accepts it. For example, Gateway listeners can restrict
   168                        which Routes can attach to them by Route kind, namespace,
   169                        or hostname. If 1 of 2 Gateway listeners accept attachment
   170                        from the referencing Route, the Route MUST be considered successfully
   171                        attached. If no Gateway listeners accept attachment from this
   172                        Route, the Route MUST be considered detached from the Gateway.
   173                        \n Support: Core"
   174                      maxLength: 253
   175                      minLength: 1
   176                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   177                      type: string
   178                  required:
   179                  - name
   180                  type: object
   181                maxItems: 32
   182                type: array
   183              rules:
   184                default:
   185                - matches:
   186                  - path:
   187                      type: PathPrefix
   188                      value: /
   189                description: Rules are a list of HTTP matchers, filters and actions.
   190                items:
   191                  description: HTTPRouteRule defines semantics for matching an HTTP
   192                    request based on conditions (matches) and processing it (filters).
   193                  properties:
   194                    backendRefs:
   195                      type: array
   196                      items:
   197                        type: object
   198                        properties:
   199                          name:
   200                            type: string
   201                          port:
   202                            type: integer
   203                          namespace:
   204                            type: string
   205                            default: "default"
   206                          filters:
   207                            description: "Filters defined at this level should be
   208                              executed if and only if the request is being forwarded
   209                              to the backend defined here. \n Support: Implementation-specific
   210                              (For broader support of filters, use the Filters field
   211                              in HTTPRouteRule.)"
   212                            items:
   213                              description: HTTPRouteFilter defines processing steps
   214                                that must be completed during the request or response
   215                                lifecycle. HTTPRouteFilters are meant as an extension
   216                                point to express processing that may be done in Gateway
   217                                implementations. Some examples include request or
   218                                response modification, implementing authentication
   219                                strategies, rate-limiting, and traffic shaping. API
   220                                guarantee/conformance is defined based on the type
   221                                of the filter.
   222                              properties:
   223                                requestHeaderModifier:
   224                                  description: "RequestHeaderModifier defines a schema
   225                                    for a filter that modifies request headers. \n
   226                                    Support: Core"
   227                                  properties:
   228                                    add:
   229                                      description: "Add adds the given header(s) (name,
   230                                        value) to the request before the action. It
   231                                        appends to any existing values associated
   232                                        with the header name. \n Input: GET /foo HTTP/1.1
   233                                        my-header: foo \n Config: add: - name: \"my-header\"
   234                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
   235                                        my-header: foo,bar,baz"
   236                                      items:
   237                                        description: HTTPHeader represents an HTTP
   238                                          Header name and value as defined by RFC
   239                                          7230.
   240                                        properties:
   241                                          name:
   242                                            description: "Name is the name of the
   243                                              HTTP Header to be matched. Name matching
   244                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   245                                              \n If multiple entries specify equivalent
   246                                              header names, the first entry with an
   247                                              equivalent name MUST be considered for
   248                                              a match. Subsequent entries with an
   249                                              equivalent header name MUST be ignored.
   250                                              Due to the case-insensitivity of header
   251                                              names, \"foo\" and \"Foo\" are considered
   252                                              equivalent."
   253                                            maxLength: 256
   254                                            minLength: 1
   255                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   256                                            type: string
   257                                          value:
   258                                            description: Value is the value of HTTP
   259                                              Header to be matched.
   260                                            maxLength: 4096
   261                                            minLength: 1
   262                                            type: string
   263                                        required:
   264                                        - name
   265                                        - value
   266                                        type: object
   267                                      maxItems: 16
   268                                      type: array
   269                                      x-kubernetes-list-map-keys:
   270                                      - name
   271                                      x-kubernetes-list-type: map
   272                                    remove:
   273                                      description: "Remove the given header(s) from
   274                                        the HTTP request before the action. The value
   275                                        of Remove is a list of HTTP header names.
   276                                        Note that the header names are case-insensitive
   277                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   278                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
   279                                        my-header2: bar my-header3: baz \n Config:
   280                                        remove: [\"my-header1\", \"my-header3\"] \n
   281                                        Output: GET /foo HTTP/1.1 my-header2: bar"
   282                                      items:
   283                                        type: string
   284                                      maxItems: 16
   285                                      type: array
   286                                    set:
   287                                      description: "Set overwrites the request with
   288                                        the given header (name, value) before the
   289                                        action. \n Input: GET /foo HTTP/1.1 my-header:
   290                                        foo \n Config: set: - name: \"my-header\"
   291                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
   292                                        my-header: bar"
   293                                      items:
   294                                        description: HTTPHeader represents an HTTP
   295                                          Header name and value as defined by RFC
   296                                          7230.
   297                                        properties:
   298                                          name:
   299                                            description: "Name is the name of the
   300                                              HTTP Header to be matched. Name matching
   301                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   302                                              \n If multiple entries specify equivalent
   303                                              header names, the first entry with an
   304                                              equivalent name MUST be considered for
   305                                              a match. Subsequent entries with an
   306                                              equivalent header name MUST be ignored.
   307                                              Due to the case-insensitivity of header
   308                                              names, \"foo\" and \"Foo\" are considered
   309                                              equivalent."
   310                                            maxLength: 256
   311                                            minLength: 1
   312                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   313                                            type: string
   314                                          value:
   315                                            description: Value is the value of HTTP
   316                                              Header to be matched.
   317                                            maxLength: 4096
   318                                            minLength: 1
   319                                            type: string
   320                                        required:
   321                                        - name
   322                                        - value
   323                                        type: object
   324                                      maxItems: 16
   325                                      type: array
   326                                      x-kubernetes-list-map-keys:
   327                                      - name
   328                                      x-kubernetes-list-type: map
   329                                  type: object
   330                                requestRedirect:
   331                                  description: "RequestRedirect defines a schema for
   332                                    a filter that responds to the request with an
   333                                    HTTP redirection. \n Support: Core"
   334                                  properties:
   335                                    hostname:
   336                                      description: "Hostname is the hostname to be
   337                                        used in the value of the `Location` header
   338                                        in the response. When empty, the hostname
   339                                        in the `Host` header of the request is used.
   340                                        \n Support: Core"
   341                                      maxLength: 253
   342                                      minLength: 1
   343                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   344                                      type: string
   345                                    path:
   346                                      description: "Path defines parameters used to
   347                                        modify the path of the incoming request. The
   348                                        modified path is then used to construct the
   349                                        `Location` header. When empty, the request
   350                                        path is used as-is. \n Support: Extended"
   351                                      properties:
   352                                        replaceFullPath:
   353                                          description: ReplaceFullPath specifies the
   354                                            value with which to replace the full path
   355                                            of a request during a rewrite or redirect.
   356                                          maxLength: 1024
   357                                          type: string
   358                                        replacePrefixMatch:
   359                                          description: "ReplacePrefixMatch specifies
   360                                            the value with which to replace the prefix
   361                                            match of a request during a rewrite or
   362                                            redirect. For example, a request to \"/foo/bar\"
   363                                            with a prefix match of \"/foo\" and a
   364                                            ReplacePrefixMatch of \"/xyz\" would be
   365                                            modified to \"/xyz/bar\". \n Note that
   366                                            this matches the behavior of the PathPrefix
   367                                            match type. This matches full path elements.
   368                                            A path element refers to the list of labels
   369                                            in the path split by the `/` separator.
   370                                            When specified, a trailing `/` is ignored.
   371                                            For example, the paths `/abc`, `/abc/`,
   372                                            and `/abc/def` would all match the prefix
   373                                            `/abc`, but the path `/abcd` would not.
   374                                            \n Request Path | Prefix Match | Replace
   375                                            Prefix | Modified Path -------------|--------------|----------------|----------
   376                                            /foo/bar     | /foo         | /xyz           |
   377                                            /xyz/bar /foo/bar     | /foo         |
   378                                            /xyz/          | /xyz/bar /foo/bar     |
   379                                            /foo/        | /xyz           | /xyz/bar
   380                                            /foo/bar     | /foo/        | /xyz/          |
   381                                            /xyz/bar /foo         | /foo         |
   382                                            /xyz           | /xyz /foo/        | /foo
   383                                            \        | /xyz           | /xyz/ /foo/bar
   384                                            \    | /foo         | <empty string> |
   385                                            /bar /foo/        | /foo         | <empty
   386                                            string> | / /foo         | /foo         |
   387                                            <empty string> | / /foo/        | /foo
   388                                            \        | /              | / /foo         |
   389                                            /foo         | /              | /"
   390                                          maxLength: 1024
   391                                          type: string
   392                                        type:
   393                                          description: "Type defines the type of path
   394                                            modifier. Additional types may be added
   395                                            in a future release of the API. \n Note
   396                                            that values may be added to this enum,
   397                                            implementations must ensure that unknown
   398                                            values will not cause a crash. \n Unknown
   399                                            values here must result in the implementation
   400                                            setting the Accepted Condition for the
   401                                            Route to `status: False`, with a Reason
   402                                            of `UnsupportedValue`."
   403                                          enum:
   404                                          - ReplaceFullPath
   405                                          - ReplacePrefixMatch
   406                                          type: string
   407                                      required:
   408                                      - type
   409                                      type: object
   410                                    port:
   411                                      description: "Port is the port to be used in
   412                                        the value of the `Location` header in the
   413                                        response. \n If no port is specified, the
   414                                        redirect port MUST be derived using the following
   415                                        rules: \n * If redirect scheme is not-empty,
   416                                        the redirect port MUST be the well-known port
   417                                        associated with the redirect scheme. Specifically
   418                                        \"http\" to port 80 and \"https\" to port
   419                                        443. If the redirect scheme does not have
   420                                        a well-known port, the listener port of the
   421                                        Gateway SHOULD be used. * If redirect scheme
   422                                        is empty, the redirect port MUST be the Gateway
   423                                        Listener port. \n Implementations SHOULD NOT
   424                                        add the port number in the 'Location' header
   425                                        in the following cases: \n * A Location header
   426                                        that will use HTTP (whether that is determined
   427                                        via the Listener protocol or the Scheme field)
   428                                        _and_ use port 80. * A Location header that
   429                                        will use HTTPS (whether that is determined
   430                                        via the Listener protocol or the Scheme field)
   431                                        _and_ use port 443. \n Support: Extended"
   432                                      format: int32
   433                                      maximum: 65535
   434                                      minimum: 1
   435                                      type: integer
   436                                    scheme:
   437                                      description: "Scheme is the scheme to be used
   438                                        in the value of the `Location` header in the
   439                                        response. When empty, the scheme of the request
   440                                        is used. \n Scheme redirects can affect the
   441                                        port of the redirect, for more information,
   442                                        refer to the documentation for the port field
   443                                        of this filter. \n Note that values may be
   444                                        added to this enum, implementations must ensure
   445                                        that unknown values will not cause a crash.
   446                                        \n Unknown values here must result in the
   447                                        implementation setting the Accepted Condition
   448                                        for the Route to `status: False`, with a Reason
   449                                        of `UnsupportedValue`. \n Support: Extended"
   450                                      enum:
   451                                      - http
   452                                      - https
   453                                      type: string
   454                                    statusCode:
   455                                      default: 302
   456                                      description: "StatusCode is the HTTP status
   457                                        code to be used in response. \n Note that
   458                                        values may be added to this enum, implementations
   459                                        must ensure that unknown values will not cause
   460                                        a crash. \n Unknown values here must result
   461                                        in the implementation setting the Accepted
   462                                        Condition for the Route to `status: False`,
   463                                        with a Reason of `UnsupportedValue`. \n Support:
   464                                        Core"
   465                                      enum:
   466                                      - 301
   467                                      - 302
   468                                      type: integer
   469                                  type: object
   470                                responseHeaderModifier:
   471                                  description: "ResponseHeaderModifier defines a schema
   472                                    for a filter that modifies response headers. \n
   473                                    Support: Extended"
   474                                  properties:
   475                                    add:
   476                                      description: "Add adds the given header(s) (name,
   477                                        value) to the request before the action. It
   478                                        appends to any existing values associated
   479                                        with the header name. \n Input: GET /foo HTTP/1.1
   480                                        my-header: foo \n Config: add: - name: \"my-header\"
   481                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
   482                                        my-header: foo,bar,baz"
   483                                      items:
   484                                        description: HTTPHeader represents an HTTP
   485                                          Header name and value as defined by RFC
   486                                          7230.
   487                                        properties:
   488                                          name:
   489                                            description: "Name is the name of the
   490                                              HTTP Header to be matched. Name matching
   491                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   492                                              \n If multiple entries specify equivalent
   493                                              header names, the first entry with an
   494                                              equivalent name MUST be considered for
   495                                              a match. Subsequent entries with an
   496                                              equivalent header name MUST be ignored.
   497                                              Due to the case-insensitivity of header
   498                                              names, \"foo\" and \"Foo\" are considered
   499                                              equivalent."
   500                                            maxLength: 256
   501                                            minLength: 1
   502                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   503                                            type: string
   504                                          value:
   505                                            description: Value is the value of HTTP
   506                                              Header to be matched.
   507                                            maxLength: 4096
   508                                            minLength: 1
   509                                            type: string
   510                                        required:
   511                                        - name
   512                                        - value
   513                                        type: object
   514                                      maxItems: 16
   515                                      type: array
   516                                      x-kubernetes-list-map-keys:
   517                                      - name
   518                                      x-kubernetes-list-type: map
   519                                    remove:
   520                                      description: "Remove the given header(s) from
   521                                        the HTTP request before the action. The value
   522                                        of Remove is a list of HTTP header names.
   523                                        Note that the header names are case-insensitive
   524                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   525                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
   526                                        my-header2: bar my-header3: baz \n Config:
   527                                        remove: [\"my-header1\", \"my-header3\"] \n
   528                                        Output: GET /foo HTTP/1.1 my-header2: bar"
   529                                      items:
   530                                        type: string
   531                                      maxItems: 16
   532                                      type: array
   533                                    set:
   534                                      description: "Set overwrites the request with
   535                                        the given header (name, value) before the
   536                                        action. \n Input: GET /foo HTTP/1.1 my-header:
   537                                        foo \n Config: set: - name: \"my-header\"
   538                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
   539                                        my-header: bar"
   540                                      items:
   541                                        description: HTTPHeader represents an HTTP
   542                                          Header name and value as defined by RFC
   543                                          7230.
   544                                        properties:
   545                                          name:
   546                                            description: "Name is the name of the
   547                                              HTTP Header to be matched. Name matching
   548                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   549                                              \n If multiple entries specify equivalent
   550                                              header names, the first entry with an
   551                                              equivalent name MUST be considered for
   552                                              a match. Subsequent entries with an
   553                                              equivalent header name MUST be ignored.
   554                                              Due to the case-insensitivity of header
   555                                              names, \"foo\" and \"Foo\" are considered
   556                                              equivalent."
   557                                            maxLength: 256
   558                                            minLength: 1
   559                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   560                                            type: string
   561                                          value:
   562                                            description: Value is the value of HTTP
   563                                              Header to be matched.
   564                                            maxLength: 4096
   565                                            minLength: 1
   566                                            type: string
   567                                        required:
   568                                        - name
   569                                        - value
   570                                        type: object
   571                                      maxItems: 16
   572                                      type: array
   573                                      x-kubernetes-list-map-keys:
   574                                      - name
   575                                      x-kubernetes-list-type: map
   576                                  type: object
   577                                type:
   578                                  description: "Type identifies the type of filter
   579                                    to apply. As with other API fields, types are
   580                                    classified into three conformance levels: \n -
   581                                    Core: Filter types and their corresponding configuration
   582                                    defined by \"Support: Core\" in this package,
   583                                    e.g. \"RequestHeaderModifier\". All implementations
   584                                    must support core filters. \n - Extended: Filter
   585                                    types and their corresponding configuration defined
   586                                    by \"Support: Extended\" in this package, e.g.
   587                                    \"RequestMirror\". Implementers are encouraged
   588                                    to support extended filters. \n - Implementation-specific:
   589                                    Filters that are defined and supported by specific
   590                                    vendors. In the future, filters showing convergence
   591                                    in behavior across multiple implementations will
   592                                    be considered for inclusion in extended or core
   593                                    conformance levels. Filter-specific configuration
   594                                    for such filters is specified using the ExtensionRef
   595                                    field. `Type` should be set to \"ExtensionRef\"
   596                                    for custom filters. \n Implementers are encouraged
   597                                    to define custom implementation types to extend
   598                                    the core API with implementation-specific behavior.
   599                                    \n If a reference to a custom filter type cannot
   600                                    be resolved, the filter MUST NOT be skipped. Instead,
   601                                    requests that would have been processed by that
   602                                    filter MUST receive a HTTP error response. \n
   603                                    Note that values may be added to this enum, implementations
   604                                    must ensure that unknown values will not cause
   605                                    a crash. \n Unknown values here must result in
   606                                    the implementation setting the Accepted Condition
   607                                    for the Route to `status: False`, with a Reason
   608                                    of `UnsupportedValue`."
   609                                  enum:
   610                                  - RequestHeaderModifier
   611                                  - ResponseHeaderModifier
   612                                  - RequestRedirect
   613                                  type: string
   614                              required:
   615                              - type
   616                              type: object
   617                            maxItems: 16
   618                            type: array
   619                    filters:
   620                      description: "Filters define the filters that are applied to
   621                        requests that match this rule. \n The effects of ordering
   622                        of multiple behaviors are currently unspecified. This can
   623                        change in the future based on feedback during the alpha stage.
   624                        \n Conformance-levels at this level are defined based on the
   625                        type of filter: \n - ALL core filters MUST be supported by
   626                        all implementations. - Implementers are encouraged to support
   627                        extended filters. - Implementation-specific custom filters
   628                        have no API guarantees across   implementations. \n Specifying
   629                        a core filter multiple times has unspecified or custom conformance.
   630                        \n All filters are expected to be compatible with each other
   631                        except for the URLRewrite and RequestRedirect filters, which
   632                        may not be combined. If an implementation can not support
   633                        other combinations of filters, they must clearly document
   634                        that limitation. In all cases where incompatible or unsupported
   635                        filters are specified, implementations MUST add a warning
   636                        condition to status. \n Support: Core"
   637                      items:
   638                        description: HTTPRouteFilter defines processing steps that
   639                          must be completed during the request or response lifecycle.
   640                          HTTPRouteFilters are meant as an extension point to express
   641                          processing that may be done in Gateway implementations.
   642                          Some examples include request or response modification,
   643                          implementing authentication strategies, rate-limiting, and
   644                          traffic shaping. API guarantee/conformance is defined based
   645                          on the type of the filter.
   646                        properties:
   647                          requestHeaderModifier:
   648                            description: "RequestHeaderModifier defines a schema for
   649                              a filter that modifies request headers. \n Support:
   650                              Core"
   651                            properties:
   652                              add:
   653                                description: "Add adds the given header(s) (name,
   654                                  value) to the request before the action. It appends
   655                                  to any existing values associated with the header
   656                                  name. \n Input:   GET /foo HTTP/1.1   my-header:
   657                                  foo \n Config:   add:   - name: \"my-header\"     value:
   658                                  \"bar\" \n Output:   GET /foo HTTP/1.1   my-header:
   659                                  foo   my-header: bar"
   660                                items:
   661                                  description: HTTPHeader represents an HTTP Header
   662                                    name and value as defined by RFC 7230.
   663                                  properties:
   664                                    name:
   665                                      description: "Name is the name of the HTTP Header
   666                                        to be matched. Name matching MUST be case
   667                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   668                                        \n If multiple entries specify equivalent
   669                                        header names, the first entry with an equivalent
   670                                        name MUST be considered for a match. Subsequent
   671                                        entries with an equivalent header name MUST
   672                                        be ignored. Due to the case-insensitivity
   673                                        of header names, \"foo\" and \"Foo\" are considered
   674                                        equivalent."
   675                                      maxLength: 256
   676                                      minLength: 1
   677                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   678                                      type: string
   679                                    value:
   680                                      description: Value is the value of HTTP Header
   681                                        to be matched.
   682                                      maxLength: 4096
   683                                      minLength: 1
   684                                      type: string
   685                                  required:
   686                                  - name
   687                                  - value
   688                                  type: object
   689                                maxItems: 16
   690                                type: array
   691                                x-kubernetes-list-map-keys:
   692                                - name
   693                                x-kubernetes-list-type: map
   694                              remove:
   695                                description: "Remove the given header(s) from the
   696                                  HTTP request before the action. The value of Remove
   697                                  is a list of HTTP header names. Note that the header
   698                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   699                                  \n Input:   GET /foo HTTP/1.1   my-header1: foo
   700                                  \  my-header2: bar   my-header3: baz \n Config:
   701                                  \  remove: [\"my-header1\", \"my-header3\"] \n Output:
   702                                  \  GET /foo HTTP/1.1   my-header2: bar"
   703                                items:
   704                                  type: string
   705                                maxItems: 16
   706                                type: array
   707                              set:
   708                                description: "Set overwrites the request with the
   709                                  given header (name, value) before the action. \n
   710                                  Input:   GET /foo HTTP/1.1   my-header: foo \n Config:
   711                                  \  set:   - name: \"my-header\"     value: \"bar\"
   712                                  \n Output:   GET /foo HTTP/1.1   my-header: bar"
   713                                items:
   714                                  description: HTTPHeader represents an HTTP Header
   715                                    name and value as defined by RFC 7230.
   716                                  properties:
   717                                    name:
   718                                      description: "Name is the name of the HTTP Header
   719                                        to be matched. Name matching MUST be case
   720                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   721                                        \n If multiple entries specify equivalent
   722                                        header names, the first entry with an equivalent
   723                                        name MUST be considered for a match. Subsequent
   724                                        entries with an equivalent header name MUST
   725                                        be ignored. Due to the case-insensitivity
   726                                        of header names, \"foo\" and \"Foo\" are considered
   727                                        equivalent."
   728                                      maxLength: 256
   729                                      minLength: 1
   730                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   731                                      type: string
   732                                    value:
   733                                      description: Value is the value of HTTP Header
   734                                        to be matched.
   735                                      maxLength: 4096
   736                                      minLength: 1
   737                                      type: string
   738                                  required:
   739                                  - name
   740                                  - value
   741                                  type: object
   742                                maxItems: 16
   743                                type: array
   744                                x-kubernetes-list-map-keys:
   745                                - name
   746                                x-kubernetes-list-type: map
   747                            type: object
   748                          requestRedirect:
   749                            description: "RequestRedirect defines a schema for a filter
   750                              that responds to the request with an HTTP redirection.
   751                              \n Support: Core"
   752                            properties:
   753                              hostname:
   754                                description: "Hostname is the hostname to be used
   755                                  in the value of the `Location` header in the response.
   756                                  When empty, the hostname of the request is used.
   757                                  \n Support: Core"
   758                                maxLength: 253
   759                                minLength: 1
   760                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   761                                type: string
   762                              path:
   763                                description: "Path defines parameters used to
   764                                  modify the path of the incoming request. The
   765                                  modified path is then used to construct the
   766                                  `Location` header. When empty, the request
   767                                  path is used as-is. \n Support: Extended"
   768                                properties:
   769                                  replaceFullPath:
   770                                    description: ReplaceFullPath specifies the
   771                                      value with which to replace the full path
   772                                      of a request during a rewrite or redirect.
   773                                    maxLength: 1024
   774                                    type: string
   775                                  replacePrefixMatch:
   776                                    description: "ReplacePrefixMatch specifies
   777                                      the value with which to replace the prefix
   778                                      match of a request during a rewrite or
   779                                      redirect. For example, a request to \"/foo/bar\"
   780                                      with a prefix match of \"/foo\" and a
   781                                      ReplacePrefixMatch of \"/xyz\" would be
   782                                      modified to \"/xyz/bar\". \n Note that
   783                                      this matches the behavior of the PathPrefix
   784                                      match type. This matches full path elements.
   785                                      A path element refers to the list of labels
   786                                      in the path split by the `/` separator.
   787                                      When specified, a trailing `/` is ignored.
   788                                      For example, the paths `/abc`, `/abc/`,
   789                                      and `/abc/def` would all match the prefix
   790                                      `/abc`, but the path `/abcd` would not.
   791                                      \n Request Path | Prefix Match | Replace
   792                                      Prefix | Modified Path -------------|--------------|----------------|----------
   793                                      /foo/bar     | /foo         | /xyz           |
   794                                      /xyz/bar /foo/bar     | /foo         |
   795                                      /xyz/          | /xyz/bar /foo/bar     |
   796                                      /foo/        | /xyz           | /xyz/bar
   797                                      /foo/bar     | /foo/        | /xyz/          |
   798                                      /xyz/bar /foo         | /foo         |
   799                                      /xyz           | /xyz /foo/        | /foo
   800                                      \        | /xyz           | /xyz/ /foo/bar
   801                                      \    | /foo         | <empty string> |
   802                                      /bar /foo/        | /foo         | <empty
   803                                      string> | / /foo         | /foo         |
   804                                      <empty string> | / /foo/        | /foo
   805                                      \        | /              | / /foo         |
   806                                      /foo         | /              | /"
   807                                    maxLength: 1024
   808                                    type: string
   809                                  type:
   810                                    description: "Type defines the type of path
   811                                      modifier. Additional types may be added
   812                                      in a future release of the API. \n Note
   813                                      that values may be added to this enum,
   814                                      implementations must ensure that unknown
   815                                      values will not cause a crash. \n Unknown
   816                                      values here must result in the implementation
   817                                      setting the Accepted Condition for the
   818                                      Route to `status: False`, with a Reason
   819                                      of `UnsupportedValue`."
   820                                    enum:
   821                                    - ReplaceFullPath
   822                                    - ReplacePrefixMatch
   823                                    type: string
   824                                required:
   825                                - type
   826                                type: object
   827                              port:
   828                                description: "Port is the port to be used in the value
   829                                  of the `Location` header in the response. When empty,
   830                                  port (if specified) of the request is used. \n Support:
   831                                  Extended"
   832                                format: int32
   833                                maximum: 65535
   834                                minimum: 1
   835                                type: integer
   836                              scheme:
   837                                description: "Scheme is the scheme to be used in the
   838                                  value of the `Location` header in the response.
   839                                  When empty, the scheme of the request is used. \n
   840                                  Support: Extended"
   841                                enum:
   842                                - http
   843                                - https
   844                                type: string
   845                              statusCode:
   846                                default: 302
   847                                description: "StatusCode is the HTTP status code to
   848                                  be used in response. \n Support: Core"
   849                                enum:
   850                                - 301
   851                                - 302
   852                                type: integer
   853                            type: object
   854                          type:
   855                            description: "Type identifies the type of filter to apply.
   856                              As with other API fields, types are classified into
   857                              three conformance levels: \n - Core: Filter types and
   858                              their corresponding configuration defined by   \"Support:
   859                              Core\" in this package, e.g. \"RequestHeaderModifier\".
   860                              All   implementations must support core filters. \n\n "
   861                            enum:
   862                            - RequestHeaderModifier
   863                            - RequestRedirect
   864                            type: string
   865                        required:
   866                        - type
   867                        type: object
   868                      maxItems: 16
   869                      type: array
   870                    matches:
   871                      default:
   872                      - path:
   873                          type: PathPrefix
   874                          value: /
   875                      description: "Matches define conditions used for matching the
   876                        rule against incoming HTTP requests. Each match is independent,
   877                        i.e. this rule will be matched if **any** one of the matches
   878                        is satisfied. \n For example, take the following matches configuration:
   879                        \n ``` matches: - path:     value: \"/foo\"   headers:   -
   880                        name: \"version\"     value: \"v2\" - path:     value: \"/v2/foo\"
   881                        ``` \n For a request to match against this rule, a request
   882                        must satisfy EITHER of the two conditions: \n - path prefixed
   883                        with `/foo` AND contains the header `version: v2` - path prefix
   884                        of `/v2/foo` \n See the documentation for HTTPRouteMatch on
   885                        how to specify multiple match conditions that should be ANDed
   886                        together. \n If no matches are specified, the default is a
   887                        prefix path match on \"/\", which has the effect of matching
   888                        every HTTP request. \n Proxy or Load Balancer routing configuration
   889                        generated from HTTPRoutes MUST prioritize rules based on the
   890                        following criteria, continuing on ties. Precedence must be
   891                        given to the the Rule with the largest number of: \n * Characters
   892                        in a matching non-wildcard hostname. * Characters in a matching
   893                        hostname. * Characters in a matching path. * Header matches.
   894                        * Query param matches. \n If ties still exist across multiple
   895                        Routes, matching precedence MUST be determined in order of
   896                        the following criteria, continuing on ties: \n * The oldest
   897                        Route based on creation timestamp. * The Route appearing first
   898                        in alphabetical order by   \"{namespace}/{name}\". \n If ties
   899                        still exist within the Route that has been given precedence,
   900                        matching precedence MUST be granted to the first matching
   901                        rule meeting the above criteria. \n When no rules matching
   902                        a request have been successfully attached to the parent a
   903                        request is coming from, a HTTP 404 status code MUST be returned."
   904                      items:
   905                        description: "HTTPRouteMatch defines the predicate used to
   906                          match requests to a given action. Multiple match types are
   907                          ANDed together, i.e. the match will evaluate to true only
   908                          if all conditions are satisfied. \n For example, the match
   909                          below will match a HTTP request only if its path starts
   910                          with `/foo` AND it contains the `version: v1` header: \n
   911                          ``` match:   path:     value: \"/foo\"   headers:   - name:
   912                          \"version\"     value \"v1\" ```"
   913                        properties:
   914                          headers:
   915                            description: Headers specifies HTTP request header matchers.
   916                              Multiple match values are ANDed together, meaning, a
   917                              request must match all the specified headers to select
   918                              the route.
   919                            items:
   920                              description: HTTPHeaderMatch describes how to select
   921                                a HTTP route by matching HTTP request headers.
   922                              properties:
   923                                name:
   924                                  description: "Name is the name of the HTTP Header
   925                                    to be matched. Name matching MUST be case insensitive.
   926                                    (See https://tools.ietf.org/html/rfc7230#section-3.2).
   927                                    \n If multiple entries specify equivalent header
   928                                    names, only the first entry with an equivalent
   929                                    name MUST be considered for a match. Subsequent
   930                                    entries with an equivalent header name MUST be
   931                                    ignored. Due to the case-insensitivity of header
   932                                    names, \"foo\" and \"Foo\" are considered equivalent.
   933                                    \n When a header is repeated in an HTTP request,
   934                                    it is implementation-specific behavior as to how
   935                                    this is represented. Generally, proxies should
   936                                    follow the guidance from the RFC: https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2.2
   937                                    regarding processing a repeated header, with special
   938                                    handling for \"Set-Cookie\"."
   939                                  maxLength: 256
   940                                  minLength: 1
   941                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   942                                  type: string
   943                                type:
   944                                  default: Exact
   945                                  description: "Type specifies how to match against
   946                                    the value of the header. \n Support: Core (Exact)
   947                                    \n Support: Custom (RegularExpression) \n Since
   948                                    RegularExpression HeaderMatchType has custom conformance,
   949                                    implementations can support POSIX, PCRE or any
   950                                    other dialects of regular expressions. Please
   951                                    read the implementation's documentation to determine
   952                                    the supported dialect."
   953                                  enum:
   954                                  - Exact
   955                                  - RegularExpression
   956                                  type: string
   957                                value:
   958                                  description: Value is the value of HTTP Header to
   959                                    be matched.
   960                                  maxLength: 4096
   961                                  minLength: 1
   962                                  type: string
   963                              required:
   964                              - name
   965                              - value
   966                              type: object
   967                            maxItems: 16
   968                            type: array
   969                            x-kubernetes-list-map-keys:
   970                            - name
   971                            x-kubernetes-list-type: map
   972                          method:
   973                            description: "Method specifies HTTP method matcher. When
   974                              specified, this route will be matched only if the request
   975                              has the specified method. \n Support: Extended"
   976                            enum:
   977                            - GET
   978                            - HEAD
   979                            - POST
   980                            - PUT
   981                            - DELETE
   982                            - CONNECT
   983                            - OPTIONS
   984                            - TRACE
   985                            - PATCH
   986                            type: string
   987                          path:
   988                            default:
   989                              type: PathPrefix
   990                              value: /
   991                            description: Path specifies a HTTP request path matcher.
   992                              If this field is not specified, a default prefix match
   993                              on the "/" path is provided.
   994                            properties:
   995                              type:
   996                                default: PathPrefix
   997                                description: "Type specifies how to match against
   998                                  the path Value. \n Support: Core (Exact, PathPrefix)
   999                                  \n Support: Custom (RegularExpression)"
  1000                                enum:
  1001                                - Exact
  1002                                - PathPrefix
  1003                                - RegularExpression
  1004                                type: string
  1005                              value:
  1006                                default: /
  1007                                description: Value of the HTTP path to match against.
  1008                                maxLength: 1024
  1009                                type: string
  1010                            type: object
  1011                          queryParams:
  1012                            description: QueryParams specifies HTTP query parameter
  1013                              matchers. Multiple match values are ANDed together,
  1014                              meaning, a request must match all the specified query
  1015                              parameters to select the route.
  1016                            items:
  1017                              description: HTTPQueryParamMatch describes how to select
  1018                                a HTTP route by matching HTTP query parameters.
  1019                              properties:
  1020                                name:
  1021                                  description: Name is the name of the HTTP query
  1022                                    param to be matched. This must be an exact string
  1023                                    match. (See https://tools.ietf.org/html/rfc7230#section-2.7.3).
  1024                                  maxLength: 256
  1025                                  minLength: 1
  1026                                  type: string
  1027                                type:
  1028                                  default: Exact
  1029                                  description: "Type specifies how to match against
  1030                                    the value of the query parameter. \n Support:
  1031                                    Extended (Exact) \n Support: Custom (RegularExpression)
  1032                                    \n Since RegularExpression QueryParamMatchType
  1033                                    has custom conformance, implementations can support
  1034                                    POSIX, PCRE or any other dialects of regular expressions.
  1035                                    Please read the implementation's documentation
  1036                                    to determine the supported dialect."
  1037                                  enum:
  1038                                  - Exact
  1039                                  - RegularExpression
  1040                                  type: string
  1041                                value:
  1042                                  description: Value is the value of HTTP query param
  1043                                    to be matched.
  1044                                  maxLength: 1024
  1045                                  minLength: 1
  1046                                  type: string
  1047                              required:
  1048                              - name
  1049                              - value
  1050                              type: object
  1051                            maxItems: 16
  1052                            type: array
  1053                            x-kubernetes-list-map-keys:
  1054                            - name
  1055                            x-kubernetes-list-type: map
  1056                        type: object
  1057                      maxItems: 8
  1058                      type: array
  1059                  type: object
  1060                maxItems: 16
  1061                type: array
  1062            type: object
  1063          status:
  1064            description: Status defines the current state of HTTPRoute.
  1065            properties:
  1066              parents:
  1067                description: "Parents is a list of parent resources (usually Gateways)
  1068                  that are associated with the route, and the status of the route
  1069                  with respect to each parent. When this route attaches to a parent,
  1070                  the controller that manages the parent must add an entry to this
  1071                  list when the controller first sees the route and should update
  1072                  the entry as appropriate when the route or gateway is modified.
  1073                  \n Note that parent references that cannot be resolved by an implementation
  1074                  of this API will not be added to this list. Implementations of this
  1075                  API can only populate Route status for the Gateways/parent resources
  1076                  they are responsible for. \n A maximum of 32 Gateways will be represented
  1077                  in this list. An empty list means the route has not been attached
  1078                  to any Gateway."
  1079                items:
  1080                  description: RouteParentStatus describes the status of a route with
  1081                    respect to an associated Parent.
  1082                  properties:
  1083                    conditions:
  1084                      description: "Conditions describes the status of the route with
  1085                        respect to the Gateway. Note that the route's availability
  1086                        is also subject to the Gateway's own status conditions and
  1087                        listener status. \n If the Route's ParentRef specifies an
  1088                        existing Gateway that supports Routes of this kind AND that
  1089                        Gateway's controller has sufficient access, then that Gateway's
  1090                        controller MUST set the \"Accepted\" condition on the Route,
  1091                        to indicate whether the route has been accepted or rejected
  1092                        by the Gateway, and why. \n A Route MUST be considered \"Accepted\"
  1093                        if at least one of the Route's rules is implemented by the
  1094                        Gateway. \n There are a number of cases where the \"Accepted\"
  1095                        condition may not be set due to lack of controller visibility,
  1096                        that includes when: \n * The Route refers to a non-existent
  1097                        parent. * The Route is of a type that the controller does
  1098                        not support. * The Route is in a namespace the the controller
  1099                        does not have access to."
  1100                      items:
  1101                        description: "Condition contains details for one aspect of
  1102                          the current state of this API Resource. --- This struct
  1103                          is intended for direct use as an array at the field path
  1104                          .status.conditions.  For example, type FooStatus struct{
  1105                          \    // Represents the observations of a foo's current state.
  1106                          \    // Known .status.conditions.type are: \"Available\",
  1107                          \"Progressing\", and \"Degraded\"     // +patchMergeKey=type
  1108                          \    // +patchStrategy=merge     // +listType=map     //
  1109                          +listMapKey=type     Conditions []metav1.Condition `json:\"conditions,omitempty\"
  1110                          patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"`
  1111                          \n     // other fields }"
  1112                        properties:
  1113                          lastTransitionTime:
  1114                            description: lastTransitionTime is the last time the condition
  1115                              transitioned from one status to another. This should
  1116                              be when the underlying condition changed.  If that is
  1117                              not known, then using the time when the API field changed
  1118                              is acceptable.
  1119                            format: date-time
  1120                            type: string
  1121                          message:
  1122                            description: message is a human readable message indicating
  1123                              details about the transition. This may be an empty string.
  1124                            maxLength: 32768
  1125                            type: string
  1126                          observedGeneration:
  1127                            description: observedGeneration represents the .metadata.generation
  1128                              that the condition was set based upon. For instance,
  1129                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
  1130                              is 9, the condition is out of date with respect to the
  1131                              current state of the instance.
  1132                            format: int64
  1133                            minimum: 0
  1134                            type: integer
  1135                          reason:
  1136                            description: reason contains a programmatic identifier
  1137                              indicating the reason for the condition's last transition.
  1138                              Producers of specific condition types may define expected
  1139                              values and meanings for this field, and whether the
  1140                              values are considered a guaranteed API. The value should
  1141                              be a CamelCase string. This field may not be empty.
  1142                            maxLength: 1024
  1143                            minLength: 1
  1144                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
  1145                            type: string
  1146                          status:
  1147                            description: status of the condition, one of True, False,
  1148                              Unknown.
  1149                            enum:
  1150                            - "True"
  1151                            - "False"
  1152                            - Unknown
  1153                            type: string
  1154                          type:
  1155                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
  1156                              --- Many .condition.type values are consistent across
  1157                              resources like Available, but because arbitrary conditions
  1158                              can be useful (see .node.status.conditions), the ability
  1159                              to deconflict is important. The regex it matches is
  1160                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
  1161                            maxLength: 316
  1162                            pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
  1163                            type: string
  1164                        required:
  1165                        - lastTransitionTime
  1166                        - message
  1167                        - reason
  1168                        - status
  1169                        - type
  1170                        type: object
  1171                      maxItems: 8
  1172                      minItems: 1
  1173                      type: array
  1174                      x-kubernetes-list-map-keys:
  1175                      - type
  1176                      x-kubernetes-list-type: map
  1177                    controllerName:
  1178                      description: "ControllerName is a domain/path string that indicates
  1179                        the name of the controller that wrote this status. This corresponds
  1180                        with the controllerName field on GatewayClass. \n Example:
  1181                        \"example.net/gateway-controller\". \n The format of this
  1182                        field is DOMAIN \"/\" PATH, where DOMAIN and PATH are valid
  1183                        Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names).
  1184                        \n Controllers MUST populate this field when writing status.
  1185                        Controllers should ensure that entries to status populated
  1186                        with their ControllerName are cleaned up when they are no
  1187                        longer necessary."
  1188                      maxLength: 253
  1189                      minLength: 1
  1190                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$
  1191                      type: string
  1192                    parentRef:
  1193                      description: ParentRef corresponds with a ParentRef in the spec
  1194                        that this RouteParentStatus struct describes the status of.
  1195                      properties:
  1196                        group:
  1197                          default: policy.linkerd.io
  1198                          description: "Group is the group of the referent. \n Support:
  1199                            Core"
  1200                          maxLength: 253
  1201                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1202                          type: string
  1203                        kind:
  1204                          default: Gateway
  1205                          description: "Kind is kind of the referent. \n Support:
  1206                            Core (Gateway) Support: Custom (Other Resources)"
  1207                          maxLength: 63
  1208                          minLength: 1
  1209                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  1210                          type: string
  1211                        name:
  1212                          description: "Name is the name of the referent. \n Support:
  1213                            Core"
  1214                          maxLength: 253
  1215                          minLength: 1
  1216                          type: string
  1217                        namespace:
  1218                          description: "Namespace is the namespace of the referent.
  1219                            When unspecified (or empty string), this refers to the
  1220                            local namespace of the Route. \n Support: Core"
  1221                          maxLength: 63
  1222                          minLength: 1
  1223                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  1224                          type: string
  1225                        port:
  1226                          description: "Port is the network port this Route targets.
  1227                            It can be interpreted differently based on the type of
  1228                            parent resource. \n When the parent resource is a Gateway,
  1229                            this targets all listeners listening on the specified
  1230                            port that also support this kind of Route(and select this
  1231                            Route). It's not recommended to set `Port` unless the
  1232                            networking behaviors specified in a Route must apply to
  1233                            a specific port as opposed to a listener(s) whose port(s)
  1234                            may be changed. When both Port and SectionName are specified,
  1235                            the name and port of the selected listener must match
  1236                            both specified values. \n Implementations MAY choose to
  1237                            support other parent resources. Implementations supporting
  1238                            other types of parent resources MUST clearly document
  1239                            how/if Port is interpreted. \n For the purpose of status,
  1240                            an attachment is considered successful as long as the
  1241                            parent resource accepts it partially. For example, Gateway
  1242                            listeners can restrict which Routes can attach to them
  1243                            by Route kind, namespace, or hostname. If 1 of 2 Gateway
  1244                            listeners accept attachment from the referencing Route,
  1245                            the Route MUST be considered successfully attached. If
  1246                            no Gateway listeners accept attachment from this Route,
  1247                            the Route MUST be considered detached from the Gateway.
  1248                            \n Support: Extended \n <gateway:experimental>"
  1249                          format: int32
  1250                          maximum: 65535
  1251                          minimum: 1
  1252                          type: integer
  1253                        sectionName:
  1254                          description: "SectionName is the name of a section within
  1255                            the target resource. In the following resources, SectionName
  1256                            is interpreted as the following: \n * Gateway: Listener
  1257                            Name. When both Port (experimental) and SectionName are
  1258                            specified, the name and port of the selected listener
  1259                            must match both specified values. \n Implementations MAY
  1260                            choose to support attaching Routes to other resources.
  1261                            If that is the case, they MUST clearly document how SectionName
  1262                            is interpreted. \n When unspecified (empty string), this
  1263                            will reference the entire resource. For the purpose of
  1264                            status, an attachment is considered successful if at least
  1265                            one section in the parent resource accepts it. For example,
  1266                            Gateway listeners can restrict which Routes can attach
  1267                            to them by Route kind, namespace, or hostname. If 1 of
  1268                            2 Gateway listeners accept attachment from the referencing
  1269                            Route, the Route MUST be considered successfully attached.
  1270                            If no Gateway listeners accept attachment from this Route,
  1271                            the Route MUST be considered detached from the Gateway.
  1272                            \n Support: Core"
  1273                          maxLength: 253
  1274                          minLength: 1
  1275                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1276                          type: string
  1277                      required:
  1278                      - name
  1279                      type: object
  1280                  required:
  1281                  - controllerName
  1282                  - parentRef
  1283                  type: object
  1284                maxItems: 32
  1285                type: array
  1286            required:
  1287            - parents
  1288            type: object
  1289        required:
  1290        - spec
  1291        type: object
  1292    served: true
  1293    storage: false
  1294    subresources:
  1295      status: {}
  1296  - additionalPrinterColumns:
  1297    - jsonPath: .spec.hostnames
  1298      name: Hostnames
  1299      type: string
  1300    - jsonPath: .metadata.creationTimestamp
  1301      name: Age
  1302      type: date
  1303    name: v1beta1
  1304    schema:
  1305      openAPIV3Schema:
  1306        description: HTTPRoute provides a way to route HTTP requests. This includes
  1307          the capability to match requests by hostname, path, header, or query param.
  1308          Filters can be used to specify additional processing steps. Backends specify
  1309          where matching requests should be routed.
  1310        properties:
  1311          apiVersion:
  1312            description: 'APIVersion defines the versioned schema of this representation
  1313              of an object. Servers should convert recognized schemas to the latest
  1314              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
  1315            type: string
  1316          kind:
  1317            description: 'Kind is a string value representing the REST resource this
  1318              object represents. Servers may infer this from the endpoint the client
  1319              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
  1320            type: string
  1321          metadata:
  1322            type: object
  1323          spec:
  1324            description: Spec defines the desired state of HTTPRoute.
  1325            properties:
  1326              hostnames:
  1327                description: "Hostnames defines a set of hostname that should match
  1328                  against the HTTP Host header to select a HTTPRoute to process the
  1329                  request. This matches the RFC 1123 definition of a hostname with
  1330                  2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname may
  1331                  be prefixed with a wildcard label (`*.`). The wildcard    label
  1332                  must appear by itself as the first label. \n If a hostname is specified
  1333                  by both the Listener and HTTPRoute, there must be at least one intersecting
  1334                  hostname for the HTTPRoute to be attached to the Listener. For example:
  1335                  \n * A Listener with `test.example.com` as the hostname matches
  1336                  HTTPRoutes   that have either not specified any hostnames, or have
  1337                  specified at   least one of `test.example.com` or `*.example.com`.
  1338                  * A Listener with `*.example.com` as the hostname matches HTTPRoutes
  1339                  \  that have either not specified any hostnames or have specified
  1340                  at least   one hostname that matches the Listener hostname. For
  1341                  example,   `*.example.com`, `test.example.com`, and `foo.test.example.com`
  1342                  would   all match. On the other hand, `example.com` and `test.example.net`
  1343                  would   not match. \n Hostnames that are prefixed with a wildcard
  1344                  label (`*.`) are interpreted as a suffix match. That means that
  1345                  a match for `*.example.com` would match both `test.example.com`,
  1346                  and `foo.test.example.com`, but not `example.com`. \n If both the
  1347                  Listener and HTTPRoute have specified hostnames, any HTTPRoute hostnames
  1348                  that do not match the Listener hostname MUST be ignored. For example,
  1349                  if a Listener specified `*.example.com`, and the HTTPRoute specified
  1350                  `test.example.com` and `test.example.net`, `test.example.net` must
  1351                  not be considered for a match. \n If both the Listener and HTTPRoute
  1352                  have specified hostnames, and none match with the criteria above,
  1353                  then the HTTPRoute is not accepted. The implementation must raise
  1354                  an 'Accepted' Condition with a status of `False` in the corresponding
  1355                  RouteParentStatus. \n Support: Core"
  1356                items:
  1357                  description: "Hostname is the fully qualified domain name of a network
  1358                    host. This matches the RFC 1123 definition of a hostname with
  1359                    2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
  1360                    may be prefixed with a wildcard label (`*.`). The wildcard    label
  1361                    must appear by itself as the first label. \n Hostname can be \"precise\"
  1362                    which is a domain name without the terminating dot of a network
  1363                    host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
  1364                    name prefixed with a single wildcard label (e.g. `*.example.com`).
  1365                    \n Note that as per RFC1035 and RFC1123, a *label* must consist
  1366                    of lower case alphanumeric characters or '-', and must start and
  1367                    end with an alphanumeric character. No other punctuation is allowed."
  1368                  maxLength: 253
  1369                  minLength: 1
  1370                  pattern: ^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1371                  type: string
  1372                maxItems: 16
  1373                type: array
  1374              parentRefs:
  1375                description: "ParentRefs references the resources (usually Gateways)
  1376                  that a Route wants to be attached to. Note that the referenced parent
  1377                  resource needs to allow this for the attachment to be complete.
  1378                  For Gateways, that means the Gateway needs to allow attachment from
  1379                  Routes of this kind and namespace. \n The only kind of parent resource
  1380                  with \"Core\" support is Gateway. This API may be extended in the
  1381                  future to support additional kinds of parent resources such as one
  1382                  of the route kinds. \n It is invalid to reference an identical parent
  1383                  more than once. It is valid to reference multiple distinct sections
  1384                  within the same parent resource, such as 2 Listeners within a Gateway.
  1385                  \n It is possible to separately reference multiple distinct objects
  1386                  that may be collapsed by an implementation. For example, some implementations
  1387                  may choose to merge compatible Gateway Listeners together. If that
  1388                  is the case, the list of routes attached to those resources should
  1389                  also be merged."
  1390                items:
  1391                  description: "ParentReference identifies an API object (usually
  1392                    a Gateway) that can be considered a parent of this resource (usually
  1393                    a route). The only kind of parent resource with \"Core\" support
  1394                    is Gateway. This API may be extended in the future to support
  1395                    additional kinds of parent resources, such as HTTPRoute. \n The
  1396                    API object must be valid in the cluster; the Group and Kind must
  1397                    be registered in the cluster for this reference to be valid."
  1398                  properties:
  1399                    group:
  1400                      default: policy.linkerd.io
  1401                      description: "Group is the group of the referent. \n Support:
  1402                        Core"
  1403                      maxLength: 253
  1404                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1405                      type: string
  1406                    kind:
  1407                      default: Gateway
  1408                      description: "Kind is kind of the referent. \n Support: Core
  1409                        (Gateway) Support: Custom (Other Resources)"
  1410                      maxLength: 63
  1411                      minLength: 1
  1412                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  1413                      type: string
  1414                    name:
  1415                      description: "Name is the name of the referent. \n Support:
  1416                        Core"
  1417                      maxLength: 253
  1418                      minLength: 1
  1419                      type: string
  1420                    namespace:
  1421                      description: "Namespace is the namespace of the referent. When
  1422                        unspecified (or empty string), this refers to the local namespace
  1423                        of the Route. \n Support: Core"
  1424                      maxLength: 63
  1425                      minLength: 1
  1426                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  1427                      type: string
  1428                    port:
  1429                      description: "port"
  1430                      type: integer
  1431                    sectionName:
  1432                      description: "SectionName is the name of a section within the
  1433                        target resource. In the following resources, SectionName is
  1434                        interpreted as the following: \n * Gateway: Listener Name.
  1435                        When both Port (experimental) and SectionName are specified,
  1436                        the name and port of the selected listener must match both
  1437                        specified values. \n Implementations MAY choose to support
  1438                        attaching Routes to other resources. If that is the case,
  1439                        they MUST clearly document how SectionName is interpreted.
  1440                        \n When unspecified (empty string), this will reference the
  1441                        entire resource. For the purpose of status, an attachment
  1442                        is considered successful if at least one section in the parent
  1443                        resource accepts it. For example, Gateway listeners can restrict
  1444                        which Routes can attach to them by Route kind, namespace,
  1445                        or hostname. If 1 of 2 Gateway listeners accept attachment
  1446                        from the referencing Route, the Route MUST be considered successfully
  1447                        attached. If no Gateway listeners accept attachment from this
  1448                        Route, the Route MUST be considered detached from the Gateway.
  1449                        \n Support: Core"
  1450                      maxLength: 253
  1451                      minLength: 1
  1452                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1453                      type: string
  1454                  required:
  1455                  - name
  1456                  type: object
  1457                maxItems: 32
  1458                type: array
  1459              rules:
  1460                default:
  1461                - matches:
  1462                  - path:
  1463                      type: PathPrefix
  1464                      value: /
  1465                description: Rules are a list of HTTP matchers, filters and actions.
  1466                items:
  1467                  description: HTTPRouteRule defines semantics for matching an HTTP
  1468                    request based on conditions (matches) and processing it (filters).
  1469                  properties:
  1470                    backendRefs:
  1471                      type: array
  1472                      items:
  1473                        type: object
  1474                        properties:
  1475                          name:
  1476                            type: string
  1477                          port:
  1478                            type: integer
  1479                          namespace:
  1480                            type: string
  1481                            default: "default"
  1482                          filters:
  1483                            description: "Filters defined at this level should be
  1484                              executed if and only if the request is being forwarded
  1485                              to the backend defined here. \n Support: Implementation-specific
  1486                              (For broader support of filters, use the Filters field
  1487                              in HTTPRouteRule.)"
  1488                            items:
  1489                              description: HTTPRouteFilter defines processing steps
  1490                                that must be completed during the request or response
  1491                                lifecycle. HTTPRouteFilters are meant as an extension
  1492                                point to express processing that may be done in Gateway
  1493                                implementations. Some examples include request or
  1494                                response modification, implementing authentication
  1495                                strategies, rate-limiting, and traffic shaping. API
  1496                                guarantee/conformance is defined based on the type
  1497                                of the filter.
  1498                              properties:
  1499                                requestHeaderModifier:
  1500                                  description: "RequestHeaderModifier defines a schema
  1501                                    for a filter that modifies request headers. \n
  1502                                    Support: Core"
  1503                                  properties:
  1504                                    add:
  1505                                      description: "Add adds the given header(s) (name,
  1506                                        value) to the request before the action. It
  1507                                        appends to any existing values associated
  1508                                        with the header name. \n Input: GET /foo HTTP/1.1
  1509                                        my-header: foo \n Config: add: - name: \"my-header\"
  1510                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  1511                                        my-header: foo,bar,baz"
  1512                                      items:
  1513                                        description: HTTPHeader represents an HTTP
  1514                                          Header name and value as defined by RFC
  1515                                          7230.
  1516                                        properties:
  1517                                          name:
  1518                                            description: "Name is the name of the
  1519                                              HTTP Header to be matched. Name matching
  1520                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1521                                              \n If multiple entries specify equivalent
  1522                                              header names, the first entry with an
  1523                                              equivalent name MUST be considered for
  1524                                              a match. Subsequent entries with an
  1525                                              equivalent header name MUST be ignored.
  1526                                              Due to the case-insensitivity of header
  1527                                              names, \"foo\" and \"Foo\" are considered
  1528                                              equivalent."
  1529                                            maxLength: 256
  1530                                            minLength: 1
  1531                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1532                                            type: string
  1533                                          value:
  1534                                            description: Value is the value of HTTP
  1535                                              Header to be matched.
  1536                                            maxLength: 4096
  1537                                            minLength: 1
  1538                                            type: string
  1539                                        required:
  1540                                        - name
  1541                                        - value
  1542                                        type: object
  1543                                      maxItems: 16
  1544                                      type: array
  1545                                      x-kubernetes-list-map-keys:
  1546                                      - name
  1547                                      x-kubernetes-list-type: map
  1548                                    remove:
  1549                                      description: "Remove the given header(s) from
  1550                                        the HTTP request before the action. The value
  1551                                        of Remove is a list of HTTP header names.
  1552                                        Note that the header names are case-insensitive
  1553                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  1554                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  1555                                        my-header2: bar my-header3: baz \n Config:
  1556                                        remove: [\"my-header1\", \"my-header3\"] \n
  1557                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  1558                                      items:
  1559                                        type: string
  1560                                      maxItems: 16
  1561                                      type: array
  1562                                    set:
  1563                                      description: "Set overwrites the request with
  1564                                        the given header (name, value) before the
  1565                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  1566                                        foo \n Config: set: - name: \"my-header\"
  1567                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  1568                                        my-header: bar"
  1569                                      items:
  1570                                        description: HTTPHeader represents an HTTP
  1571                                          Header name and value as defined by RFC
  1572                                          7230.
  1573                                        properties:
  1574                                          name:
  1575                                            description: "Name is the name of the
  1576                                              HTTP Header to be matched. Name matching
  1577                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1578                                              \n If multiple entries specify equivalent
  1579                                              header names, the first entry with an
  1580                                              equivalent name MUST be considered for
  1581                                              a match. Subsequent entries with an
  1582                                              equivalent header name MUST be ignored.
  1583                                              Due to the case-insensitivity of header
  1584                                              names, \"foo\" and \"Foo\" are considered
  1585                                              equivalent."
  1586                                            maxLength: 256
  1587                                            minLength: 1
  1588                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1589                                            type: string
  1590                                          value:
  1591                                            description: Value is the value of HTTP
  1592                                              Header to be matched.
  1593                                            maxLength: 4096
  1594                                            minLength: 1
  1595                                            type: string
  1596                                        required:
  1597                                        - name
  1598                                        - value
  1599                                        type: object
  1600                                      maxItems: 16
  1601                                      type: array
  1602                                      x-kubernetes-list-map-keys:
  1603                                      - name
  1604                                      x-kubernetes-list-type: map
  1605                                  type: object
  1606                                requestRedirect:
  1607                                  description: "RequestRedirect defines a schema for
  1608                                    a filter that responds to the request with an
  1609                                    HTTP redirection. \n Support: Core"
  1610                                  properties:
  1611                                    hostname:
  1612                                      description: "Hostname is the hostname to be
  1613                                        used in the value of the `Location` header
  1614                                        in the response. When empty, the hostname
  1615                                        in the `Host` header of the request is used.
  1616                                        \n Support: Core"
  1617                                      maxLength: 253
  1618                                      minLength: 1
  1619                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1620                                      type: string
  1621                                    path:
  1622                                      description: "Path defines parameters used to
  1623                                        modify the path of the incoming request. The
  1624                                        modified path is then used to construct the
  1625                                        `Location` header. When empty, the request
  1626                                        path is used as-is. \n Support: Extended"
  1627                                      properties:
  1628                                        replaceFullPath:
  1629                                          description: ReplaceFullPath specifies the
  1630                                            value with which to replace the full path
  1631                                            of a request during a rewrite or redirect.
  1632                                          maxLength: 1024
  1633                                          type: string
  1634                                        replacePrefixMatch:
  1635                                          description: "ReplacePrefixMatch specifies
  1636                                            the value with which to replace the prefix
  1637                                            match of a request during a rewrite or
  1638                                            redirect. For example, a request to \"/foo/bar\"
  1639                                            with a prefix match of \"/foo\" and a
  1640                                            ReplacePrefixMatch of \"/xyz\" would be
  1641                                            modified to \"/xyz/bar\". \n Note that
  1642                                            this matches the behavior of the PathPrefix
  1643                                            match type. This matches full path elements.
  1644                                            A path element refers to the list of labels
  1645                                            in the path split by the `/` separator.
  1646                                            When specified, a trailing `/` is ignored.
  1647                                            For example, the paths `/abc`, `/abc/`,
  1648                                            and `/abc/def` would all match the prefix
  1649                                            `/abc`, but the path `/abcd` would not.
  1650                                            \n Request Path | Prefix Match | Replace
  1651                                            Prefix | Modified Path -------------|--------------|----------------|----------
  1652                                            /foo/bar     | /foo         | /xyz           |
  1653                                            /xyz/bar /foo/bar     | /foo         |
  1654                                            /xyz/          | /xyz/bar /foo/bar     |
  1655                                            /foo/        | /xyz           | /xyz/bar
  1656                                            /foo/bar     | /foo/        | /xyz/          |
  1657                                            /xyz/bar /foo         | /foo         |
  1658                                            /xyz           | /xyz /foo/        | /foo
  1659                                            \        | /xyz           | /xyz/ /foo/bar
  1660                                            \    | /foo         | <empty string> |
  1661                                            /bar /foo/        | /foo         | <empty
  1662                                            string> | / /foo         | /foo         |
  1663                                            <empty string> | / /foo/        | /foo
  1664                                            \        | /              | / /foo         |
  1665                                            /foo         | /              | /"
  1666                                          maxLength: 1024
  1667                                          type: string
  1668                                        type:
  1669                                          description: "Type defines the type of path
  1670                                            modifier. Additional types may be added
  1671                                            in a future release of the API. \n Note
  1672                                            that values may be added to this enum,
  1673                                            implementations must ensure that unknown
  1674                                            values will not cause a crash. \n Unknown
  1675                                            values here must result in the implementation
  1676                                            setting the Accepted Condition for the
  1677                                            Route to `status: False`, with a Reason
  1678                                            of `UnsupportedValue`."
  1679                                          enum:
  1680                                          - ReplaceFullPath
  1681                                          - ReplacePrefixMatch
  1682                                          type: string
  1683                                      required:
  1684                                      - type
  1685                                      type: object
  1686                                    port:
  1687                                      description: "Port is the port to be used in
  1688                                        the value of the `Location` header in the
  1689                                        response. \n If no port is specified, the
  1690                                        redirect port MUST be derived using the following
  1691                                        rules: \n * If redirect scheme is not-empty,
  1692                                        the redirect port MUST be the well-known port
  1693                                        associated with the redirect scheme. Specifically
  1694                                        \"http\" to port 80 and \"https\" to port
  1695                                        443. If the redirect scheme does not have
  1696                                        a well-known port, the listener port of the
  1697                                        Gateway SHOULD be used. * If redirect scheme
  1698                                        is empty, the redirect port MUST be the Gateway
  1699                                        Listener port. \n Implementations SHOULD NOT
  1700                                        add the port number in the 'Location' header
  1701                                        in the following cases: \n * A Location header
  1702                                        that will use HTTP (whether that is determined
  1703                                        via the Listener protocol or the Scheme field)
  1704                                        _and_ use port 80. * A Location header that
  1705                                        will use HTTPS (whether that is determined
  1706                                        via the Listener protocol or the Scheme field)
  1707                                        _and_ use port 443. \n Support: Extended"
  1708                                      format: int32
  1709                                      maximum: 65535
  1710                                      minimum: 1
  1711                                      type: integer
  1712                                    scheme:
  1713                                      description: "Scheme is the scheme to be used
  1714                                        in the value of the `Location` header in the
  1715                                        response. When empty, the scheme of the request
  1716                                        is used. \n Scheme redirects can affect the
  1717                                        port of the redirect, for more information,
  1718                                        refer to the documentation for the port field
  1719                                        of this filter. \n Note that values may be
  1720                                        added to this enum, implementations must ensure
  1721                                        that unknown values will not cause a crash.
  1722                                        \n Unknown values here must result in the
  1723                                        implementation setting the Accepted Condition
  1724                                        for the Route to `status: False`, with a Reason
  1725                                        of `UnsupportedValue`. \n Support: Extended"
  1726                                      enum:
  1727                                      - http
  1728                                      - https
  1729                                      type: string
  1730                                    statusCode:
  1731                                      default: 302
  1732                                      description: "StatusCode is the HTTP status
  1733                                        code to be used in response. \n Note that
  1734                                        values may be added to this enum, implementations
  1735                                        must ensure that unknown values will not cause
  1736                                        a crash. \n Unknown values here must result
  1737                                        in the implementation setting the Accepted
  1738                                        Condition for the Route to `status: False`,
  1739                                        with a Reason of `UnsupportedValue`. \n Support:
  1740                                        Core"
  1741                                      enum:
  1742                                      - 301
  1743                                      - 302
  1744                                      type: integer
  1745                                  type: object
  1746                                responseHeaderModifier:
  1747                                  description: "ResponseHeaderModifier defines a schema
  1748                                    for a filter that modifies response headers. \n
  1749                                    Support: Extended"
  1750                                  properties:
  1751                                    add:
  1752                                      description: "Add adds the given header(s) (name,
  1753                                        value) to the request before the action. It
  1754                                        appends to any existing values associated
  1755                                        with the header name. \n Input: GET /foo HTTP/1.1
  1756                                        my-header: foo \n Config: add: - name: \"my-header\"
  1757                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  1758                                        my-header: foo,bar,baz"
  1759                                      items:
  1760                                        description: HTTPHeader represents an HTTP
  1761                                          Header name and value as defined by RFC
  1762                                          7230.
  1763                                        properties:
  1764                                          name:
  1765                                            description: "Name is the name of the
  1766                                              HTTP Header to be matched. Name matching
  1767                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1768                                              \n If multiple entries specify equivalent
  1769                                              header names, the first entry with an
  1770                                              equivalent name MUST be considered for
  1771                                              a match. Subsequent entries with an
  1772                                              equivalent header name MUST be ignored.
  1773                                              Due to the case-insensitivity of header
  1774                                              names, \"foo\" and \"Foo\" are considered
  1775                                              equivalent."
  1776                                            maxLength: 256
  1777                                            minLength: 1
  1778                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1779                                            type: string
  1780                                          value:
  1781                                            description: Value is the value of HTTP
  1782                                              Header to be matched.
  1783                                            maxLength: 4096
  1784                                            minLength: 1
  1785                                            type: string
  1786                                        required:
  1787                                        - name
  1788                                        - value
  1789                                        type: object
  1790                                      maxItems: 16
  1791                                      type: array
  1792                                      x-kubernetes-list-map-keys:
  1793                                      - name
  1794                                      x-kubernetes-list-type: map
  1795                                    remove:
  1796                                      description: "Remove the given header(s) from
  1797                                        the HTTP request before the action. The value
  1798                                        of Remove is a list of HTTP header names.
  1799                                        Note that the header names are case-insensitive
  1800                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  1801                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  1802                                        my-header2: bar my-header3: baz \n Config:
  1803                                        remove: [\"my-header1\", \"my-header3\"] \n
  1804                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  1805                                      items:
  1806                                        type: string
  1807                                      maxItems: 16
  1808                                      type: array
  1809                                    set:
  1810                                      description: "Set overwrites the request with
  1811                                        the given header (name, value) before the
  1812                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  1813                                        foo \n Config: set: - name: \"my-header\"
  1814                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  1815                                        my-header: bar"
  1816                                      items:
  1817                                        description: HTTPHeader represents an HTTP
  1818                                          Header name and value as defined by RFC
  1819                                          7230.
  1820                                        properties:
  1821                                          name:
  1822                                            description: "Name is the name of the
  1823                                              HTTP Header to be matched. Name matching
  1824                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1825                                              \n If multiple entries specify equivalent
  1826                                              header names, the first entry with an
  1827                                              equivalent name MUST be considered for
  1828                                              a match. Subsequent entries with an
  1829                                              equivalent header name MUST be ignored.
  1830                                              Due to the case-insensitivity of header
  1831                                              names, \"foo\" and \"Foo\" are considered
  1832                                              equivalent."
  1833                                            maxLength: 256
  1834                                            minLength: 1
  1835                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1836                                            type: string
  1837                                          value:
  1838                                            description: Value is the value of HTTP
  1839                                              Header to be matched.
  1840                                            maxLength: 4096
  1841                                            minLength: 1
  1842                                            type: string
  1843                                        required:
  1844                                        - name
  1845                                        - value
  1846                                        type: object
  1847                                      maxItems: 16
  1848                                      type: array
  1849                                      x-kubernetes-list-map-keys:
  1850                                      - name
  1851                                      x-kubernetes-list-type: map
  1852                                  type: object
  1853                                type:
  1854                                  description: "Type identifies the type of filter
  1855                                    to apply. As with other API fields, types are
  1856                                    classified into three conformance levels: \n -
  1857                                    Core: Filter types and their corresponding configuration
  1858                                    defined by \"Support: Core\" in this package,
  1859                                    e.g. \"RequestHeaderModifier\". All implementations
  1860                                    must support core filters. \n - Extended: Filter
  1861                                    types and their corresponding configuration defined
  1862                                    by \"Support: Extended\" in this package, e.g.
  1863                                    \"RequestMirror\". Implementers are encouraged
  1864                                    to support extended filters. \n - Implementation-specific:
  1865                                    Filters that are defined and supported by specific
  1866                                    vendors. In the future, filters showing convergence
  1867                                    in behavior across multiple implementations will
  1868                                    be considered for inclusion in extended or core
  1869                                    conformance levels. Filter-specific configuration
  1870                                    for such filters is specified using the ExtensionRef
  1871                                    field. `Type` should be set to \"ExtensionRef\"
  1872                                    for custom filters. \n Implementers are encouraged
  1873                                    to define custom implementation types to extend
  1874                                    the core API with implementation-specific behavior.
  1875                                    \n If a reference to a custom filter type cannot
  1876                                    be resolved, the filter MUST NOT be skipped. Instead,
  1877                                    requests that would have been processed by that
  1878                                    filter MUST receive a HTTP error response. \n
  1879                                    Note that values may be added to this enum, implementations
  1880                                    must ensure that unknown values will not cause
  1881                                    a crash. \n Unknown values here must result in
  1882                                    the implementation setting the Accepted Condition
  1883                                    for the Route to `status: False`, with a Reason
  1884                                    of `UnsupportedValue`."
  1885                                  enum:
  1886                                  - RequestHeaderModifier
  1887                                  - ResponseHeaderModifier
  1888                                  - RequestRedirect
  1889                                  type: string
  1890                              required:
  1891                              - type
  1892                              type: object
  1893                            maxItems: 16
  1894                            type: array
  1895                    filters:
  1896                      description: "Filters define the filters that are applied to
  1897                        requests that match this rule. \n The effects of ordering
  1898                        of multiple behaviors are currently unspecified. This can
  1899                        change in the future based on feedback during the alpha stage.
  1900                        \n Conformance-levels at this level are defined based on the
  1901                        type of filter: \n - ALL core filters MUST be supported by
  1902                        all implementations. - Implementers are encouraged to support
  1903                        extended filters. - Implementation-specific custom filters
  1904                        have no API guarantees across   implementations. \n Specifying
  1905                        a core filter multiple times has unspecified or custom conformance.
  1906                        \n All filters are expected to be compatible with each other
  1907                        except for the URLRewrite and RequestRedirect filters, which
  1908                        may not be combined. If an implementation can not support
  1909                        other combinations of filters, they must clearly document
  1910                        that limitation. In all cases where incompatible or unsupported
  1911                        filters are specified, implementations MUST add a warning
  1912                        condition to status. \n Support: Core"
  1913                      items:
  1914                        description: HTTPRouteFilter defines processing steps that
  1915                          must be completed during the request or response lifecycle.
  1916                          HTTPRouteFilters are meant as an extension point to express
  1917                          processing that may be done in Gateway implementations.
  1918                          Some examples include request or response modification,
  1919                          implementing authentication strategies, rate-limiting, and
  1920                          traffic shaping. API guarantee/conformance is defined based
  1921                          on the type of the filter.
  1922                        properties:
  1923                          requestHeaderModifier:
  1924                            description: "RequestHeaderModifier defines a schema for
  1925                              a filter that modifies request headers. \n Support:
  1926                              Core"
  1927                            properties:
  1928                              add:
  1929                                description: "Add adds the given header(s) (name,
  1930                                  value) to the request before the action. It appends
  1931                                  to any existing values associated with the header
  1932                                  name. \n Input:   GET /foo HTTP/1.1   my-header:
  1933                                  foo \n Config:   add:   - name: \"my-header\"     value:
  1934                                  \"bar\" \n Output:   GET /foo HTTP/1.1   my-header:
  1935                                  foo   my-header: bar"
  1936                                items:
  1937                                  description: HTTPHeader represents an HTTP Header
  1938                                    name and value as defined by RFC 7230.
  1939                                  properties:
  1940                                    name:
  1941                                      description: "Name is the name of the HTTP Header
  1942                                        to be matched. Name matching MUST be case
  1943                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1944                                        \n If multiple entries specify equivalent
  1945                                        header names, the first entry with an equivalent
  1946                                        name MUST be considered for a match. Subsequent
  1947                                        entries with an equivalent header name MUST
  1948                                        be ignored. Due to the case-insensitivity
  1949                                        of header names, \"foo\" and \"Foo\" are considered
  1950                                        equivalent."
  1951                                      maxLength: 256
  1952                                      minLength: 1
  1953                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1954                                      type: string
  1955                                    value:
  1956                                      description: Value is the value of HTTP Header
  1957                                        to be matched.
  1958                                      maxLength: 4096
  1959                                      minLength: 1
  1960                                      type: string
  1961                                  required:
  1962                                  - name
  1963                                  - value
  1964                                  type: object
  1965                                maxItems: 16
  1966                                type: array
  1967                                x-kubernetes-list-map-keys:
  1968                                - name
  1969                                x-kubernetes-list-type: map
  1970                              remove:
  1971                                description: "Remove the given header(s) from the
  1972                                  HTTP request before the action. The value of Remove
  1973                                  is a list of HTTP header names. Note that the header
  1974                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  1975                                  \n Input:   GET /foo HTTP/1.1   my-header1: foo
  1976                                  \  my-header2: bar   my-header3: baz \n Config:
  1977                                  \  remove: [\"my-header1\", \"my-header3\"] \n Output:
  1978                                  \  GET /foo HTTP/1.1   my-header2: bar"
  1979                                items:
  1980                                  type: string
  1981                                maxItems: 16
  1982                                type: array
  1983                              set:
  1984                                description: "Set overwrites the request with the
  1985                                  given header (name, value) before the action. \n
  1986                                  Input:   GET /foo HTTP/1.1   my-header: foo \n Config:
  1987                                  \  set:   - name: \"my-header\"     value: \"bar\"
  1988                                  \n Output:   GET /foo HTTP/1.1   my-header: bar"
  1989                                items:
  1990                                  description: HTTPHeader represents an HTTP Header
  1991                                    name and value as defined by RFC 7230.
  1992                                  properties:
  1993                                    name:
  1994                                      description: "Name is the name of the HTTP Header
  1995                                        to be matched. Name matching MUST be case
  1996                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1997                                        \n If multiple entries specify equivalent
  1998                                        header names, the first entry with an equivalent
  1999                                        name MUST be considered for a match. Subsequent
  2000                                        entries with an equivalent header name MUST
  2001                                        be ignored. Due to the case-insensitivity
  2002                                        of header names, \"foo\" and \"Foo\" are considered
  2003                                        equivalent."
  2004                                      maxLength: 256
  2005                                      minLength: 1
  2006                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2007                                      type: string
  2008                                    value:
  2009                                      description: Value is the value of HTTP Header
  2010                                        to be matched.
  2011                                      maxLength: 4096
  2012                                      minLength: 1
  2013                                      type: string
  2014                                  required:
  2015                                  - name
  2016                                  - value
  2017                                  type: object
  2018                                maxItems: 16
  2019                                type: array
  2020                                x-kubernetes-list-map-keys:
  2021                                - name
  2022                                x-kubernetes-list-type: map
  2023                            type: object
  2024                          requestRedirect:
  2025                            description: "RequestRedirect defines a schema for a filter
  2026                              that responds to the request with an HTTP redirection.
  2027                              \n Support: Core"
  2028                            properties:
  2029                              hostname:
  2030                                description: "Hostname is the hostname to be used
  2031                                  in the value of the `Location` header in the response.
  2032                                  When empty, the hostname of the request is used.
  2033                                  \n Support: Core"
  2034                                maxLength: 253
  2035                                minLength: 1
  2036                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2037                                type: string
  2038                              path:
  2039                                description: "Path defines parameters used to
  2040                                  modify the path of the incoming request. The
  2041                                  modified path is then used to construct the
  2042                                  `Location` header. When empty, the request
  2043                                  path is used as-is. \n Support: Extended"
  2044                                properties:
  2045                                  replaceFullPath:
  2046                                    description: ReplaceFullPath specifies the
  2047                                      value with which to replace the full path
  2048                                      of a request during a rewrite or redirect.
  2049                                    maxLength: 1024
  2050                                    type: string
  2051                                  replacePrefixMatch:
  2052                                    description: "ReplacePrefixMatch specifies
  2053                                      the value with which to replace the prefix
  2054                                      match of a request during a rewrite or
  2055                                      redirect. For example, a request to \"/foo/bar\"
  2056                                      with a prefix match of \"/foo\" and a
  2057                                      ReplacePrefixMatch of \"/xyz\" would be
  2058                                      modified to \"/xyz/bar\". \n Note that
  2059                                      this matches the behavior of the PathPrefix
  2060                                      match type. This matches full path elements.
  2061                                      A path element refers to the list of labels
  2062                                      in the path split by the `/` separator.
  2063                                      When specified, a trailing `/` is ignored.
  2064                                      For example, the paths `/abc`, `/abc/`,
  2065                                      and `/abc/def` would all match the prefix
  2066                                      `/abc`, but the path `/abcd` would not.
  2067                                      \n Request Path | Prefix Match | Replace
  2068                                      Prefix | Modified Path -------------|--------------|----------------|----------
  2069                                      /foo/bar     | /foo         | /xyz           |
  2070                                      /xyz/bar /foo/bar     | /foo         |
  2071                                      /xyz/          | /xyz/bar /foo/bar     |
  2072                                      /foo/        | /xyz           | /xyz/bar
  2073                                      /foo/bar     | /foo/        | /xyz/          |
  2074                                      /xyz/bar /foo         | /foo         |
  2075                                      /xyz           | /xyz /foo/        | /foo
  2076                                      \        | /xyz           | /xyz/ /foo/bar
  2077                                      \    | /foo         | <empty string> |
  2078                                      /bar /foo/        | /foo         | <empty
  2079                                      string> | / /foo         | /foo         |
  2080                                      <empty string> | / /foo/        | /foo
  2081                                      \        | /              | / /foo         |
  2082                                      /foo         | /              | /"
  2083                                    maxLength: 1024
  2084                                    type: string
  2085                                  type:
  2086                                    description: "Type defines the type of path
  2087                                      modifier. Additional types may be added
  2088                                      in a future release of the API. \n Note
  2089                                      that values may be added to this enum,
  2090                                      implementations must ensure that unknown
  2091                                      values will not cause a crash. \n Unknown
  2092                                      values here must result in the implementation
  2093                                      setting the Accepted Condition for the
  2094                                      Route to `status: False`, with a Reason
  2095                                      of `UnsupportedValue`."
  2096                                    enum:
  2097                                    - ReplaceFullPath
  2098                                    - ReplacePrefixMatch
  2099                                    type: string
  2100                                required:
  2101                                - type
  2102                                type: object
  2103                              port:
  2104                                description: "Port is the port to be used in the value
  2105                                  of the `Location` header in the response. When empty,
  2106                                  port (if specified) of the request is used. \n Support:
  2107                                  Extended"
  2108                                format: int32
  2109                                maximum: 65535
  2110                                minimum: 1
  2111                                type: integer
  2112                              scheme:
  2113                                description: "Scheme is the scheme to be used in the
  2114                                  value of the `Location` header in the response.
  2115                                  When empty, the scheme of the request is used. \n
  2116                                  Support: Extended"
  2117                                enum:
  2118                                - http
  2119                                - https
  2120                                type: string
  2121                              statusCode:
  2122                                default: 302
  2123                                description: "StatusCode is the HTTP status code to
  2124                                  be used in response. \n Support: Core"
  2125                                enum:
  2126                                - 301
  2127                                - 302
  2128                                type: integer
  2129                            type: object
  2130                          type:
  2131                            description: "Type identifies the type of filter to apply.
  2132                              As with other API fields, types are classified into
  2133                              three conformance levels: \n - Core: Filter types and
  2134                              their corresponding configuration defined by   \"Support:
  2135                              Core\" in this package, e.g. \"RequestHeaderModifier\"."
  2136                            enum:
  2137                            - RequestHeaderModifier
  2138                            - RequestRedirect
  2139                            type: string
  2140                        required:
  2141                        - type
  2142                        type: object
  2143                      maxItems: 16
  2144                      type: array
  2145                    matches:
  2146                      default:
  2147                      - path:
  2148                          type: PathPrefix
  2149                          value: /
  2150                      description: "Matches define conditions used for matching the
  2151                        rule against incoming HTTP requests. Each match is independent,
  2152                        i.e. this rule will be matched if **any** one of the matches
  2153                        is satisfied. \n For example, take the following matches configuration:
  2154                        \n ``` matches: - path:     value: \"/foo\"   headers:   -
  2155                        name: \"version\"     value: \"v2\" - path:     value: \"/v2/foo\"
  2156                        ``` \n For a request to match against this rule, a request
  2157                        must satisfy EITHER of the two conditions: \n - path prefixed
  2158                        with `/foo` AND contains the header `version: v2` - path prefix
  2159                        of `/v2/foo` \n See the documentation for HTTPRouteMatch on
  2160                        how to specify multiple match conditions that should be ANDed
  2161                        together. \n If no matches are specified, the default is a
  2162                        prefix path match on \"/\", which has the effect of matching
  2163                        every HTTP request. \n Proxy or Load Balancer routing configuration
  2164                        generated from HTTPRoutes MUST prioritize rules based on the
  2165                        following criteria, continuing on ties. Precedence must be
  2166                        given to the the Rule with the largest number of: \n * Characters
  2167                        in a matching non-wildcard hostname. * Characters in a matching
  2168                        hostname. * Characters in a matching path. * Header matches.
  2169                        * Query param matches. \n If ties still exist across multiple
  2170                        Routes, matching precedence MUST be determined in order of
  2171                        the following criteria, continuing on ties: \n * The oldest
  2172                        Route based on creation timestamp. * The Route appearing first
  2173                        in alphabetical order by   \"{namespace}/{name}\". \n If ties
  2174                        still exist within the Route that has been given precedence,
  2175                        matching precedence MUST be granted to the first matching
  2176                        rule meeting the above criteria. \n When no rules matching
  2177                        a request have been successfully attached to the parent a
  2178                        request is coming from, a HTTP 404 status code MUST be returned."
  2179                      items:
  2180                        description: "HTTPRouteMatch defines the predicate used to
  2181                          match requests to a given action. Multiple match types are
  2182                          ANDed together, i.e. the match will evaluate to true only
  2183                          if all conditions are satisfied. \n For example, the match
  2184                          below will match a HTTP request only if its path starts
  2185                          with `/foo` AND it contains the `version: v1` header: \n
  2186                          ``` match:   path:     value: \"/foo\"   headers:   - name:
  2187                          \"version\"     value \"v1\" ```"
  2188                        properties:
  2189                          headers:
  2190                            description: Headers specifies HTTP request header matchers.
  2191                              Multiple match values are ANDed together, meaning, a
  2192                              request must match all the specified headers to select
  2193                              the route.
  2194                            items:
  2195                              description: HTTPHeaderMatch describes how to select
  2196                                a HTTP route by matching HTTP request headers.
  2197                              properties:
  2198                                name:
  2199                                  description: "Name is the name of the HTTP Header
  2200                                    to be matched. Name matching MUST be case insensitive.
  2201                                    (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2202                                    \n If multiple entries specify equivalent header
  2203                                    names, only the first entry with an equivalent
  2204                                    name MUST be considered for a match. Subsequent
  2205                                    entries with an equivalent header name MUST be
  2206                                    ignored. Due to the case-insensitivity of header
  2207                                    names, \"foo\" and \"Foo\" are considered equivalent.
  2208                                    \n When a header is repeated in an HTTP request,
  2209                                    it is implementation-specific behavior as to how
  2210                                    this is represented. Generally, proxies should
  2211                                    follow the guidance from the RFC: https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2.2
  2212                                    regarding processing a repeated header, with special
  2213                                    handling for \"Set-Cookie\"."
  2214                                  maxLength: 256
  2215                                  minLength: 1
  2216                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2217                                  type: string
  2218                                type:
  2219                                  default: Exact
  2220                                  description: "Type specifies how to match against
  2221                                    the value of the header. \n Support: Core (Exact)
  2222                                    \n Support: Custom (RegularExpression) \n Since
  2223                                    RegularExpression HeaderMatchType has custom conformance,
  2224                                    implementations can support POSIX, PCRE or any
  2225                                    other dialects of regular expressions. Please
  2226                                    read the implementation's documentation to determine
  2227                                    the supported dialect."
  2228                                  enum:
  2229                                  - Exact
  2230                                  - RegularExpression
  2231                                  type: string
  2232                                value:
  2233                                  description: Value is the value of HTTP Header to
  2234                                    be matched.
  2235                                  maxLength: 4096
  2236                                  minLength: 1
  2237                                  type: string
  2238                              required:
  2239                              - name
  2240                              - value
  2241                              type: object
  2242                            maxItems: 16
  2243                            type: array
  2244                            x-kubernetes-list-map-keys:
  2245                            - name
  2246                            x-kubernetes-list-type: map
  2247                          method:
  2248                            description: "Method specifies HTTP method matcher. When
  2249                              specified, this route will be matched only if the request
  2250                              has the specified method. \n Support: Extended"
  2251                            enum:
  2252                            - GET
  2253                            - HEAD
  2254                            - POST
  2255                            - PUT
  2256                            - DELETE
  2257                            - CONNECT
  2258                            - OPTIONS
  2259                            - TRACE
  2260                            - PATCH
  2261                            type: string
  2262                          path:
  2263                            default:
  2264                              type: PathPrefix
  2265                              value: /
  2266                            description: Path specifies a HTTP request path matcher.
  2267                              If this field is not specified, a default prefix match
  2268                              on the "/" path is provided.
  2269                            properties:
  2270                              type:
  2271                                default: PathPrefix
  2272                                description: "Type specifies how to match against
  2273                                  the path Value. \n Support: Core (Exact, PathPrefix)
  2274                                  \n Support: Custom (RegularExpression)"
  2275                                enum:
  2276                                - Exact
  2277                                - PathPrefix
  2278                                - RegularExpression
  2279                                type: string
  2280                              value:
  2281                                default: /
  2282                                description: Value of the HTTP path to match against.
  2283                                maxLength: 1024
  2284                                type: string
  2285                            type: object
  2286                          queryParams:
  2287                            description: QueryParams specifies HTTP query parameter
  2288                              matchers. Multiple match values are ANDed together,
  2289                              meaning, a request must match all the specified query
  2290                              parameters to select the route.
  2291                            items:
  2292                              description: HTTPQueryParamMatch describes how to select
  2293                                a HTTP route by matching HTTP query parameters.
  2294                              properties:
  2295                                name:
  2296                                  description: Name is the name of the HTTP query
  2297                                    param to be matched. This must be an exact string
  2298                                    match. (See https://tools.ietf.org/html/rfc7230#section-2.7.3).
  2299                                  maxLength: 256
  2300                                  minLength: 1
  2301                                  type: string
  2302                                type:
  2303                                  default: Exact
  2304                                  description: "Type specifies how to match against
  2305                                    the value of the query parameter. \n Support:
  2306                                    Extended (Exact) \n Support: Custom (RegularExpression)
  2307                                    \n Since RegularExpression QueryParamMatchType
  2308                                    has custom conformance, implementations can support
  2309                                    POSIX, PCRE or any other dialects of regular expressions.
  2310                                    Please read the implementation's documentation
  2311                                    to determine the supported dialect."
  2312                                  enum:
  2313                                  - Exact
  2314                                  - RegularExpression
  2315                                  type: string
  2316                                value:
  2317                                  description: Value is the value of HTTP query param
  2318                                    to be matched.
  2319                                  maxLength: 1024
  2320                                  minLength: 1
  2321                                  type: string
  2322                              required:
  2323                              - name
  2324                              - value
  2325                              type: object
  2326                            maxItems: 16
  2327                            type: array
  2328                            x-kubernetes-list-map-keys:
  2329                            - name
  2330                            x-kubernetes-list-type: map
  2331                        type: object
  2332                      maxItems: 8
  2333                      type: array
  2334                  type: object
  2335                maxItems: 16
  2336                type: array
  2337            type: object
  2338          status:
  2339            description: Status defines the current state of HTTPRoute.
  2340            properties:
  2341              parents:
  2342                description: "Parents is a list of parent resources (usually Gateways)
  2343                  that are associated with the route, and the status of the route
  2344                  with respect to each parent. When this route attaches to a parent,
  2345                  the controller that manages the parent must add an entry to this
  2346                  list when the controller first sees the route and should update
  2347                  the entry as appropriate when the route or gateway is modified.
  2348                  \n Note that parent references that cannot be resolved by an implementation
  2349                  of this API will not be added to this list. Implementations of this
  2350                  API can only populate Route status for the Gateways/parent resources
  2351                  they are responsible for. \n A maximum of 32 Gateways will be represented
  2352                  in this list. An empty list means the route has not been attached
  2353                  to any Gateway."
  2354                items:
  2355                  description: RouteParentStatus describes the status of a route with
  2356                    respect to an associated Parent.
  2357                  properties:
  2358                    conditions:
  2359                      description: "Conditions describes the status of the route with
  2360                        respect to the Gateway. Note that the route's availability
  2361                        is also subject to the Gateway's own status conditions and
  2362                        listener status. \n If the Route's ParentRef specifies an
  2363                        existing Gateway that supports Routes of this kind AND that
  2364                        Gateway's controller has sufficient access, then that Gateway's
  2365                        controller MUST set the \"Accepted\" condition on the Route,
  2366                        to indicate whether the route has been accepted or rejected
  2367                        by the Gateway, and why. \n A Route MUST be considered \"Accepted\"
  2368                        if at least one of the Route's rules is implemented by the
  2369                        Gateway. \n There are a number of cases where the \"Accepted\"
  2370                        condition may not be set due to lack of controller visibility,
  2371                        that includes when: \n * The Route refers to a non-existent
  2372                        parent. * The Route is of a type that the controller does
  2373                        not support. * The Route is in a namespace the the controller
  2374                        does not have access to."
  2375                      items:
  2376                        description: "Condition contains details for one aspect of
  2377                          the current state of this API Resource. --- This struct
  2378                          is intended for direct use as an array at the field path
  2379                          .status.conditions.  For example, type FooStatus struct{
  2380                          \    // Represents the observations of a foo's current state.
  2381                          \    // Known .status.conditions.type are: \"Available\",
  2382                          \"Progressing\", and \"Degraded\"     // +patchMergeKey=type
  2383                          \    // +patchStrategy=merge     // +listType=map     //
  2384                          +listMapKey=type     Conditions []metav1.Condition `json:\"conditions,omitempty\"
  2385                          patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"`
  2386                          \n     // other fields }"
  2387                        properties:
  2388                          lastTransitionTime:
  2389                            description: lastTransitionTime is the last time the condition
  2390                              transitioned from one status to another. This should
  2391                              be when the underlying condition changed.  If that is
  2392                              not known, then using the time when the API field changed
  2393                              is acceptable.
  2394                            format: date-time
  2395                            type: string
  2396                          message:
  2397                            description: message is a human readable message indicating
  2398                              details about the transition. This may be an empty string.
  2399                            maxLength: 32768
  2400                            type: string
  2401                          observedGeneration:
  2402                            description: observedGeneration represents the .metadata.generation
  2403                              that the condition was set based upon. For instance,
  2404                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
  2405                              is 9, the condition is out of date with respect to the
  2406                              current state of the instance.
  2407                            format: int64
  2408                            minimum: 0
  2409                            type: integer
  2410                          reason:
  2411                            description: reason contains a programmatic identifier
  2412                              indicating the reason for the condition's last transition.
  2413                              Producers of specific condition types may define expected
  2414                              values and meanings for this field, and whether the
  2415                              values are considered a guaranteed API. The value should
  2416                              be a CamelCase string. This field may not be empty.
  2417                            maxLength: 1024
  2418                            minLength: 1
  2419                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
  2420                            type: string
  2421                          status:
  2422                            description: status of the condition, one of True, False,
  2423                              Unknown.
  2424                            enum:
  2425                            - "True"
  2426                            - "False"
  2427                            - Unknown
  2428                            type: string
  2429                          type:
  2430                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
  2431                              --- Many .condition.type values are consistent across
  2432                              resources like Available, but because arbitrary conditions
  2433                              can be useful (see .node.status.conditions), the ability
  2434                              to deconflict is important. The regex it matches is
  2435                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
  2436                            maxLength: 316
  2437                            pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
  2438                            type: string
  2439                        required:
  2440                        - lastTransitionTime
  2441                        - message
  2442                        - reason
  2443                        - status
  2444                        - type
  2445                        type: object
  2446                      maxItems: 8
  2447                      minItems: 1
  2448                      type: array
  2449                      x-kubernetes-list-map-keys:
  2450                      - type
  2451                      x-kubernetes-list-type: map
  2452                    controllerName:
  2453                      description: "ControllerName is a domain/path string that indicates
  2454                        the name of the controller that wrote this status. This corresponds
  2455                        with the controllerName field on GatewayClass. \n Example:
  2456                        \"example.net/gateway-controller\". \n The format of this
  2457                        field is DOMAIN \"/\" PATH, where DOMAIN and PATH are valid
  2458                        Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names).
  2459                        \n Controllers MUST populate this field when writing status.
  2460                        Controllers should ensure that entries to status populated
  2461                        with their ControllerName are cleaned up when they are no
  2462                        longer necessary."
  2463                      maxLength: 253
  2464                      minLength: 1
  2465                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$
  2466                      type: string
  2467                    parentRef:
  2468                      description: ParentRef corresponds with a ParentRef in the spec
  2469                        that this RouteParentStatus struct describes the status of.
  2470                      properties:
  2471                        group:
  2472                          default: policy.linkerd.io
  2473                          description: "Group is the group of the referent. \n Support:
  2474                            Core"
  2475                          maxLength: 253
  2476                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2477                          type: string
  2478                        kind:
  2479                          default: Gateway
  2480                          description: "Kind is kind of the referent. \n Support:
  2481                            Core (Gateway) Support: Custom (Other Resources)"
  2482                          maxLength: 63
  2483                          minLength: 1
  2484                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2485                          type: string
  2486                        name:
  2487                          description: "Name is the name of the referent. \n Support:
  2488                            Core"
  2489                          maxLength: 253
  2490                          minLength: 1
  2491                          type: string
  2492                        namespace:
  2493                          description: "Namespace is the namespace of the referent.
  2494                            When unspecified (or empty string), this refers to the
  2495                            local namespace of the Route. \n Support: Core"
  2496                          maxLength: 63
  2497                          minLength: 1
  2498                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  2499                          type: string
  2500                        port:
  2501                          description: "Port is the network port this Route targets.
  2502                            It can be interpreted differently based on the type of
  2503                            parent resource. \n When the parent resource is a Gateway,
  2504                            this targets all listeners listening on the specified
  2505                            port that also support this kind of Route(and select this
  2506                            Route). It's not recommended to set `Port` unless the
  2507                            networking behaviors specified in a Route must apply to
  2508                            a specific port as opposed to a listener(s) whose port(s)
  2509                            may be changed. When both Port and SectionName are specified,
  2510                            the name and port of the selected listener must match
  2511                            both specified values. \n Implementations MAY choose to
  2512                            support other parent resources. Implementations supporting
  2513                            other types of parent resources MUST clearly document
  2514                            how/if Port is interpreted. \n For the purpose of status,
  2515                            an attachment is considered successful as long as the
  2516                            parent resource accepts it partially. For example, Gateway
  2517                            listeners can restrict which Routes can attach to them
  2518                            by Route kind, namespace, or hostname. If 1 of 2 Gateway
  2519                            listeners accept attachment from the referencing Route,
  2520                            the Route MUST be considered successfully attached. If
  2521                            no Gateway listeners accept attachment from this Route,
  2522                            the Route MUST be considered detached from the Gateway.
  2523                            \n Support: Extended \n <gateway:experimental>"
  2524                          format: int32
  2525                          maximum: 65535
  2526                          minimum: 1
  2527                          type: integer
  2528                        sectionName:
  2529                          description: "SectionName is the name of a section within
  2530                            the target resource. In the following resources, SectionName
  2531                            is interpreted as the following: \n * Gateway: Listener
  2532                            Name. When both Port (experimental) and SectionName are
  2533                            specified, the name and port of the selected listener
  2534                            must match both specified values. \n Implementations MAY
  2535                            choose to support attaching Routes to other resources.
  2536                            If that is the case, they MUST clearly document how SectionName
  2537                            is interpreted. \n When unspecified (empty string), this
  2538                            will reference the entire resource. For the purpose of
  2539                            status, an attachment is considered successful if at least
  2540                            one section in the parent resource accepts it. For example,
  2541                            Gateway listeners can restrict which Routes can attach
  2542                            to them by Route kind, namespace, or hostname. If 1 of
  2543                            2 Gateway listeners accept attachment from the referencing
  2544                            Route, the Route MUST be considered successfully attached.
  2545                            If no Gateway listeners accept attachment from this Route,
  2546                            the Route MUST be considered detached from the Gateway.
  2547                            \n Support: Core"
  2548                          maxLength: 253
  2549                          minLength: 1
  2550                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2551                          type: string
  2552                      required:
  2553                      - name
  2554                      type: object
  2555                  required:
  2556                  - controllerName
  2557                  - parentRef
  2558                  type: object
  2559                maxItems: 32
  2560                type: array
  2561            required:
  2562            - parents
  2563            type: object
  2564        required:
  2565        - spec
  2566        type: object
  2567    served: true
  2568    storage: false
  2569    subresources:
  2570      status: {}
  2571  - additionalPrinterColumns:
  2572    - jsonPath: .spec.hostnames
  2573      name: Hostnames
  2574      type: string
  2575    - jsonPath: .metadata.creationTimestamp
  2576      name: Age
  2577      type: date
  2578    name: v1beta2
  2579    schema:
  2580      openAPIV3Schema:
  2581        description: HTTPRoute provides a way to route HTTP requests. This includes
  2582          the capability to match requests by hostname, path, header, or query param.
  2583          Filters can be used to specify additional processing steps. Backends specify
  2584          where matching requests should be routed.
  2585        properties:
  2586          apiVersion:
  2587            description: 'APIVersion defines the versioned schema of this representation
  2588              of an object. Servers should convert recognized schemas to the latest
  2589              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
  2590            type: string
  2591          kind:
  2592            description: 'Kind is a string value representing the REST resource this
  2593              object represents. Servers may infer this from the endpoint the client
  2594              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
  2595            type: string
  2596          metadata:
  2597            type: object
  2598          spec:
  2599            description: Spec defines the desired state of HTTPRoute.
  2600            properties:
  2601              hostnames:
  2602                description: "Hostnames defines a set of hostname that should match
  2603                  against the HTTP Host header to select a HTTPRoute to process the
  2604                  request. This matches the RFC 1123 definition of a hostname with
  2605                  2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname may
  2606                  be prefixed with a wildcard label (`*.`). The wildcard    label
  2607                  must appear by itself as the first label. \n If a hostname is specified
  2608                  by both the Listener and HTTPRoute, there must be at least one intersecting
  2609                  hostname for the HTTPRoute to be attached to the Listener. For example:
  2610                  \n * A Listener with `test.example.com` as the hostname matches
  2611                  HTTPRoutes   that have either not specified any hostnames, or have
  2612                  specified at   least one of `test.example.com` or `*.example.com`.
  2613                  * A Listener with `*.example.com` as the hostname matches HTTPRoutes
  2614                  \  that have either not specified any hostnames or have specified
  2615                  at least   one hostname that matches the Listener hostname. For
  2616                  example,   `*.example.com`, `test.example.com`, and `foo.test.example.com`
  2617                  would   all match. On the other hand, `example.com` and `test.example.net`
  2618                  would   not match. \n Hostnames that are prefixed with a wildcard
  2619                  label (`*.`) are interpreted as a suffix match. That means that
  2620                  a match for `*.example.com` would match both `test.example.com`,
  2621                  and `foo.test.example.com`, but not `example.com`. \n If both the
  2622                  Listener and HTTPRoute have specified hostnames, any HTTPRoute hostnames
  2623                  that do not match the Listener hostname MUST be ignored. For example,
  2624                  if a Listener specified `*.example.com`, and the HTTPRoute specified
  2625                  `test.example.com` and `test.example.net`, `test.example.net` must
  2626                  not be considered for a match. \n If both the Listener and HTTPRoute
  2627                  have specified hostnames, and none match with the criteria above,
  2628                  then the HTTPRoute is not accepted. The implementation must raise
  2629                  an 'Accepted' Condition with a status of `False` in the corresponding
  2630                  RouteParentStatus. \n Support: Core"
  2631                items:
  2632                  description: "Hostname is the fully qualified domain name of a network
  2633                    host. This matches the RFC 1123 definition of a hostname with
  2634                    2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
  2635                    may be prefixed with a wildcard label (`*.`). The wildcard    label
  2636                    must appear by itself as the first label. \n Hostname can be \"precise\"
  2637                    which is a domain name without the terminating dot of a network
  2638                    host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
  2639                    name prefixed with a single wildcard label (e.g. `*.example.com`).
  2640                    \n Note that as per RFC1035 and RFC1123, a *label* must consist
  2641                    of lower case alphanumeric characters or '-', and must start and
  2642                    end with an alphanumeric character. No other punctuation is allowed."
  2643                  maxLength: 253
  2644                  minLength: 1
  2645                  pattern: ^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2646                  type: string
  2647                maxItems: 16
  2648                type: array
  2649              parentRefs:
  2650                description: "ParentRefs references the resources (usually Gateways)
  2651                  that a Route wants to be attached to. Note that the referenced parent
  2652                  resource needs to allow this for the attachment to be complete.
  2653                  For Gateways, that means the Gateway needs to allow attachment from
  2654                  Routes of this kind and namespace. \n The only kind of parent resource
  2655                  with \"Core\" support is Gateway. This API may be extended in the
  2656                  future to support additional kinds of parent resources such as one
  2657                  of the route kinds. \n It is invalid to reference an identical parent
  2658                  more than once. It is valid to reference multiple distinct sections
  2659                  within the same parent resource, such as 2 Listeners within a Gateway.
  2660                  \n It is possible to separately reference multiple distinct objects
  2661                  that may be collapsed by an implementation. For example, some implementations
  2662                  may choose to merge compatible Gateway Listeners together. If that
  2663                  is the case, the list of routes attached to those resources should
  2664                  also be merged."
  2665                items:
  2666                  description: "ParentReference identifies an API object (usually
  2667                    a Gateway) that can be considered a parent of this resource (usually
  2668                    a route). The only kind of parent resource with \"Core\" support
  2669                    is Gateway. This API may be extended in the future to support
  2670                    additional kinds of parent resources, such as HTTPRoute. \n The
  2671                    API object must be valid in the cluster; the Group and Kind must
  2672                    be registered in the cluster for this reference to be valid."
  2673                  properties:
  2674                    group:
  2675                      default: policy.linkerd.io
  2676                      description: "Group is the group of the referent. \n Support:
  2677                        Core"
  2678                      maxLength: 253
  2679                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2680                      type: string
  2681                    kind:
  2682                      default: Gateway
  2683                      description: "Kind is kind of the referent. \n Support: Core
  2684                        (Gateway) Support: Custom (Other Resources)"
  2685                      maxLength: 63
  2686                      minLength: 1
  2687                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2688                      type: string
  2689                    name:
  2690                      description: "Name is the name of the referent. \n Support:
  2691                        Core"
  2692                      maxLength: 253
  2693                      minLength: 1
  2694                      type: string
  2695                    namespace:
  2696                      description: "Namespace is the namespace of the referent. When
  2697                        unspecified (or empty string), this refers to the local namespace
  2698                        of the Route. \n Support: Core"
  2699                      maxLength: 63
  2700                      minLength: 1
  2701                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  2702                      type: string
  2703                    port:
  2704                      description: "Port specifies the destination
  2705                        port number to use for this resource.
  2706                        Port is required when the referent is
  2707                        a Kubernetes Service. In this case, the
  2708                        port number is the service port number,
  2709                        not the target port. For other resources,
  2710                        destination port might be derived from
  2711                        the referent resource or this field. \n Support: Extended"
  2712                      format: int32
  2713                      maximum: 65535
  2714                      minimum: 1
  2715                      type: integer
  2716                    sectionName:
  2717                      description: "SectionName is the name of a section within the
  2718                        target resource. In the following resources, SectionName is
  2719                        interpreted as the following: \n * Gateway: Listener Name.
  2720                        When both Port (experimental) and SectionName are specified,
  2721                        the name and port of the selected listener must match both
  2722                        specified values. \n Implementations MAY choose to support
  2723                        attaching Routes to other resources. If that is the case,
  2724                        they MUST clearly document how SectionName is interpreted.
  2725                        \n When unspecified (empty string), this will reference the
  2726                        entire resource. For the purpose of status, an attachment
  2727                        is considered successful if at least one section in the parent
  2728                        resource accepts it. For example, Gateway listeners can restrict
  2729                        which Routes can attach to them by Route kind, namespace,
  2730                        or hostname. If 1 of 2 Gateway listeners accept attachment
  2731                        from the referencing Route, the Route MUST be considered successfully
  2732                        attached. If no Gateway listeners accept attachment from this
  2733                        Route, the Route MUST be considered detached from the Gateway.
  2734                        \n Support: Core"
  2735                      maxLength: 253
  2736                      minLength: 1
  2737                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2738                      type: string
  2739                  required:
  2740                  - name
  2741                  type: object
  2742                maxItems: 32
  2743                type: array
  2744              rules:
  2745                default:
  2746                - matches:
  2747                  - path:
  2748                      type: PathPrefix
  2749                      value: /
  2750                description: Rules are a list of HTTP matchers, filters and actions.
  2751                items:
  2752                  description: HTTPRouteRule defines semantics for matching an HTTP
  2753                    request based on conditions (matches) and processing it (filters).
  2754                  properties:
  2755                    backendRefs:
  2756                      description: "BackendRefs defines the backend(s) where matching
  2757                        requests should be sent. \n Failure behavior here depends
  2758                        on how many BackendRefs are specified and how many are invalid.
  2759                        \n If *all* entries in BackendRefs are invalid, and there
  2760                        are also no filters specified in this route rule, *all* traffic
  2761                        which matches this rule MUST receive a 500 status code. \n
  2762                        See the HTTPBackendRef definition for the rules about what
  2763                        makes a single HTTPBackendRef invalid. \n When a HTTPBackendRef
  2764                        is invalid, 500 status codes MUST be returned for requests
  2765                        that would have otherwise been routed to an invalid backend.
  2766                        If multiple backends are specified, and some are invalid,
  2767                        the proportion of requests that would otherwise have been
  2768                        routed to an invalid backend MUST receive a 500 status code.
  2769                        \n For example, if two backends are specified with equal weights,
  2770                        and one is invalid, 50 percent of traffic must receive a 500.
  2771                        Implementations may choose how that 50 percent is determined.
  2772                        \n Support: Core for Kubernetes Service \n Support: Implementation-specific
  2773                        for any other resource \n Support for weight: Core"
  2774                      items:
  2775                        description: HTTPBackendRef defines how a HTTPRoute should
  2776                          forward an HTTP request.
  2777                        properties:
  2778                          group:
  2779                            default: ""
  2780                            description: Group is the group of the referent. For example,
  2781                              "gateway.networking.k8s.io". When unspecified or empty
  2782                              string, core API group is inferred.
  2783                            maxLength: 253
  2784                            pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2785                            type: string
  2786                          kind:
  2787                            default: Service
  2788                            description: Kind is kind of the referent. For example
  2789                              "HTTPRoute" or "Service". Defaults to "Service" when
  2790                              not specified.
  2791                            maxLength: 63
  2792                            minLength: 1
  2793                            pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  2794                            type: string
  2795                          name:
  2796                            description: Name is the name of the referent.
  2797                            maxLength: 253
  2798                            minLength: 1
  2799                            type: string
  2800                          namespace:
  2801                            description: "Namespace is the namespace of the backend.
  2802                              When unspecified, the local namespace is inferred. \n
  2803                              Note that when a namespace is specified, a ReferenceGrant
  2804                              object is required in the referent namespace to allow
  2805                              that namespace's owner to accept the reference. See
  2806                              the ReferenceGrant documentation for details. \n Support:
  2807                              Core"
  2808                            maxLength: 63
  2809                            minLength: 1
  2810                            pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  2811                            type: string
  2812                          port:
  2813                            description: Port specifies the destination port number
  2814                              to use for this resource. Port is required when the
  2815                              referent is a Kubernetes Service. In this case, the
  2816                              port number is the service port number, not the target
  2817                              port. For other resources, destination port might be
  2818                              derived from the referent resource or this field.
  2819                            format: int32
  2820                            maximum: 65535
  2821                            minimum: 1
  2822                            type: integer
  2823                          weight:
  2824                            default: 1
  2825                            description: "Weight specifies the proportion of requests
  2826                              forwarded to the referenced backend. This is computed
  2827                              as weight/(sum of all weights in this BackendRefs list).
  2828                              For non-zero values, there may be some epsilon from
  2829                              the exact proportion defined here depending on the precision
  2830                              an implementation supports. Weight is not a percentage
  2831                              and the sum of weights does not need to equal 100. \n
  2832                              If only one backend is specified and it has a weight
  2833                              greater than 0, 100% of the traffic is forwarded to
  2834                              that backend. If weight is set to 0, no traffic should
  2835                              be forwarded for this entry. If unspecified, weight
  2836                              defaults to 1. \n Support for this field varies based
  2837                              on the context where used."
  2838                            format: int32
  2839                            maximum: 1000000
  2840                            minimum: 0
  2841                            type: integer
  2842                          filters:
  2843                            description: "Filters defined at this level should be
  2844                              executed if and only if the request is being forwarded
  2845                              to the backend defined here. \n Support: Implementation-specific
  2846                              (For broader support of filters, use the Filters field
  2847                              in HTTPRouteRule.)"
  2848                            items:
  2849                              description: HTTPRouteFilter defines processing steps
  2850                                that must be completed during the request or response
  2851                                lifecycle. HTTPRouteFilters are meant as an extension
  2852                                point to express processing that may be done in Gateway
  2853                                implementations. Some examples include request or
  2854                                response modification, implementing authentication
  2855                                strategies, rate-limiting, and traffic shaping. API
  2856                                guarantee/conformance is defined based on the type
  2857                                of the filter.
  2858                              properties:
  2859                                requestHeaderModifier:
  2860                                  description: "RequestHeaderModifier defines a schema
  2861                                    for a filter that modifies request headers. \n
  2862                                    Support: Core"
  2863                                  properties:
  2864                                    add:
  2865                                      description: "Add adds the given header(s) (name,
  2866                                        value) to the request before the action. It
  2867                                        appends to any existing values associated
  2868                                        with the header name. \n Input: GET /foo HTTP/1.1
  2869                                        my-header: foo \n Config: add: - name: \"my-header\"
  2870                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  2871                                        my-header: foo,bar,baz"
  2872                                      items:
  2873                                        description: HTTPHeader represents an HTTP
  2874                                          Header name and value as defined by RFC
  2875                                          7230.
  2876                                        properties:
  2877                                          name:
  2878                                            description: "Name is the name of the
  2879                                              HTTP Header to be matched. Name matching
  2880                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2881                                              \n If multiple entries specify equivalent
  2882                                              header names, the first entry with an
  2883                                              equivalent name MUST be considered for
  2884                                              a match. Subsequent entries with an
  2885                                              equivalent header name MUST be ignored.
  2886                                              Due to the case-insensitivity of header
  2887                                              names, \"foo\" and \"Foo\" are considered
  2888                                              equivalent."
  2889                                            maxLength: 256
  2890                                            minLength: 1
  2891                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2892                                            type: string
  2893                                          value:
  2894                                            description: Value is the value of HTTP
  2895                                              Header to be matched.
  2896                                            maxLength: 4096
  2897                                            minLength: 1
  2898                                            type: string
  2899                                        required:
  2900                                        - name
  2901                                        - value
  2902                                        type: object
  2903                                      maxItems: 16
  2904                                      type: array
  2905                                      x-kubernetes-list-map-keys:
  2906                                      - name
  2907                                      x-kubernetes-list-type: map
  2908                                    remove:
  2909                                      description: "Remove the given header(s) from
  2910                                        the HTTP request before the action. The value
  2911                                        of Remove is a list of HTTP header names.
  2912                                        Note that the header names are case-insensitive
  2913                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  2914                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  2915                                        my-header2: bar my-header3: baz \n Config:
  2916                                        remove: [\"my-header1\", \"my-header3\"] \n
  2917                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  2918                                      items:
  2919                                        type: string
  2920                                      maxItems: 16
  2921                                      type: array
  2922                                    set:
  2923                                      description: "Set overwrites the request with
  2924                                        the given header (name, value) before the
  2925                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  2926                                        foo \n Config: set: - name: \"my-header\"
  2927                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  2928                                        my-header: bar"
  2929                                      items:
  2930                                        description: HTTPHeader represents an HTTP
  2931                                          Header name and value as defined by RFC
  2932                                          7230.
  2933                                        properties:
  2934                                          name:
  2935                                            description: "Name is the name of the
  2936                                              HTTP Header to be matched. Name matching
  2937                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  2938                                              \n If multiple entries specify equivalent
  2939                                              header names, the first entry with an
  2940                                              equivalent name MUST be considered for
  2941                                              a match. Subsequent entries with an
  2942                                              equivalent header name MUST be ignored.
  2943                                              Due to the case-insensitivity of header
  2944                                              names, \"foo\" and \"Foo\" are considered
  2945                                              equivalent."
  2946                                            maxLength: 256
  2947                                            minLength: 1
  2948                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  2949                                            type: string
  2950                                          value:
  2951                                            description: Value is the value of HTTP
  2952                                              Header to be matched.
  2953                                            maxLength: 4096
  2954                                            minLength: 1
  2955                                            type: string
  2956                                        required:
  2957                                        - name
  2958                                        - value
  2959                                        type: object
  2960                                      maxItems: 16
  2961                                      type: array
  2962                                      x-kubernetes-list-map-keys:
  2963                                      - name
  2964                                      x-kubernetes-list-type: map
  2965                                  type: object
  2966                                requestRedirect:
  2967                                  description: "RequestRedirect defines a schema for
  2968                                    a filter that responds to the request with an
  2969                                    HTTP redirection. \n Support: Core"
  2970                                  properties:
  2971                                    hostname:
  2972                                      description: "Hostname is the hostname to be
  2973                                        used in the value of the `Location` header
  2974                                        in the response. When empty, the hostname
  2975                                        in the `Host` header of the request is used.
  2976                                        \n Support: Core"
  2977                                      maxLength: 253
  2978                                      minLength: 1
  2979                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  2980                                      type: string
  2981                                    path:
  2982                                      description: "Path defines parameters used to
  2983                                        modify the path of the incoming request. The
  2984                                        modified path is then used to construct the
  2985                                        `Location` header. When empty, the request
  2986                                        path is used as-is. \n Support: Extended"
  2987                                      properties:
  2988                                        replaceFullPath:
  2989                                          description: ReplaceFullPath specifies the
  2990                                            value with which to replace the full path
  2991                                            of a request during a rewrite or redirect.
  2992                                          maxLength: 1024
  2993                                          type: string
  2994                                        replacePrefixMatch:
  2995                                          description: "ReplacePrefixMatch specifies
  2996                                            the value with which to replace the prefix
  2997                                            match of a request during a rewrite or
  2998                                            redirect. For example, a request to \"/foo/bar\"
  2999                                            with a prefix match of \"/foo\" and a
  3000                                            ReplacePrefixMatch of \"/xyz\" would be
  3001                                            modified to \"/xyz/bar\". \n Note that
  3002                                            this matches the behavior of the PathPrefix
  3003                                            match type. This matches full path elements.
  3004                                            A path element refers to the list of labels
  3005                                            in the path split by the `/` separator.
  3006                                            When specified, a trailing `/` is ignored.
  3007                                            For example, the paths `/abc`, `/abc/`,
  3008                                            and `/abc/def` would all match the prefix
  3009                                            `/abc`, but the path `/abcd` would not.
  3010                                            \n Request Path | Prefix Match | Replace
  3011                                            Prefix | Modified Path -------------|--------------|----------------|----------
  3012                                            /foo/bar     | /foo         | /xyz           |
  3013                                            /xyz/bar /foo/bar     | /foo         |
  3014                                            /xyz/          | /xyz/bar /foo/bar     |
  3015                                            /foo/        | /xyz           | /xyz/bar
  3016                                            /foo/bar     | /foo/        | /xyz/          |
  3017                                            /xyz/bar /foo         | /foo         |
  3018                                            /xyz           | /xyz /foo/        | /foo
  3019                                            \        | /xyz           | /xyz/ /foo/bar
  3020                                            \    | /foo         | <empty string> |
  3021                                            /bar /foo/        | /foo         | <empty
  3022                                            string> | / /foo         | /foo         |
  3023                                            <empty string> | / /foo/        | /foo
  3024                                            \        | /              | / /foo         |
  3025                                            /foo         | /              | /"
  3026                                          maxLength: 1024
  3027                                          type: string
  3028                                        type:
  3029                                          description: "Type defines the type of path
  3030                                            modifier. Additional types may be added
  3031                                            in a future release of the API. \n Note
  3032                                            that values may be added to this enum,
  3033                                            implementations must ensure that unknown
  3034                                            values will not cause a crash. \n Unknown
  3035                                            values here must result in the implementation
  3036                                            setting the Accepted Condition for the
  3037                                            Route to `status: False`, with a Reason
  3038                                            of `UnsupportedValue`."
  3039                                          enum:
  3040                                          - ReplaceFullPath
  3041                                          - ReplacePrefixMatch
  3042                                          type: string
  3043                                      required:
  3044                                      - type
  3045                                      type: object
  3046                                    port:
  3047                                      description: "Port is the port to be used in
  3048                                        the value of the `Location` header in the
  3049                                        response. \n If no port is specified, the
  3050                                        redirect port MUST be derived using the following
  3051                                        rules: \n * If redirect scheme is not-empty,
  3052                                        the redirect port MUST be the well-known port
  3053                                        associated with the redirect scheme. Specifically
  3054                                        \"http\" to port 80 and \"https\" to port
  3055                                        443. If the redirect scheme does not have
  3056                                        a well-known port, the listener port of the
  3057                                        Gateway SHOULD be used. * If redirect scheme
  3058                                        is empty, the redirect port MUST be the Gateway
  3059                                        Listener port. \n Implementations SHOULD NOT
  3060                                        add the port number in the 'Location' header
  3061                                        in the following cases: \n * A Location header
  3062                                        that will use HTTP (whether that is determined
  3063                                        via the Listener protocol or the Scheme field)
  3064                                        _and_ use port 80. * A Location header that
  3065                                        will use HTTPS (whether that is determined
  3066                                        via the Listener protocol or the Scheme field)
  3067                                        _and_ use port 443. \n Support: Extended"
  3068                                      format: int32
  3069                                      maximum: 65535
  3070                                      minimum: 1
  3071                                      type: integer
  3072                                    scheme:
  3073                                      description: "Scheme is the scheme to be used
  3074                                        in the value of the `Location` header in the
  3075                                        response. When empty, the scheme of the request
  3076                                        is used. \n Scheme redirects can affect the
  3077                                        port of the redirect, for more information,
  3078                                        refer to the documentation for the port field
  3079                                        of this filter. \n Note that values may be
  3080                                        added to this enum, implementations must ensure
  3081                                        that unknown values will not cause a crash.
  3082                                        \n Unknown values here must result in the
  3083                                        implementation setting the Accepted Condition
  3084                                        for the Route to `status: False`, with a Reason
  3085                                        of `UnsupportedValue`. \n Support: Extended"
  3086                                      enum:
  3087                                      - http
  3088                                      - https
  3089                                      type: string
  3090                                    statusCode:
  3091                                      default: 302
  3092                                      description: "StatusCode is the HTTP status
  3093                                        code to be used in response. \n Note that
  3094                                        values may be added to this enum, implementations
  3095                                        must ensure that unknown values will not cause
  3096                                        a crash. \n Unknown values here must result
  3097                                        in the implementation setting the Accepted
  3098                                        Condition for the Route to `status: False`,
  3099                                        with a Reason of `UnsupportedValue`. \n Support:
  3100                                        Core"
  3101                                      enum:
  3102                                      - 301
  3103                                      - 302
  3104                                      type: integer
  3105                                  type: object
  3106                                responseHeaderModifier:
  3107                                  description: "ResponseHeaderModifier defines a schema
  3108                                    for a filter that modifies response headers. \n
  3109                                    Support: Extended"
  3110                                  properties:
  3111                                    add:
  3112                                      description: "Add adds the given header(s) (name,
  3113                                        value) to the request before the action. It
  3114                                        appends to any existing values associated
  3115                                        with the header name. \n Input: GET /foo HTTP/1.1
  3116                                        my-header: foo \n Config: add: - name: \"my-header\"
  3117                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  3118                                        my-header: foo,bar,baz"
  3119                                      items:
  3120                                        description: HTTPHeader represents an HTTP
  3121                                          Header name and value as defined by RFC
  3122                                          7230.
  3123                                        properties:
  3124                                          name:
  3125                                            description: "Name is the name of the
  3126                                              HTTP Header to be matched. Name matching
  3127                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3128                                              \n If multiple entries specify equivalent
  3129                                              header names, the first entry with an
  3130                                              equivalent name MUST be considered for
  3131                                              a match. Subsequent entries with an
  3132                                              equivalent header name MUST be ignored.
  3133                                              Due to the case-insensitivity of header
  3134                                              names, \"foo\" and \"Foo\" are considered
  3135                                              equivalent."
  3136                                            maxLength: 256
  3137                                            minLength: 1
  3138                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3139                                            type: string
  3140                                          value:
  3141                                            description: Value is the value of HTTP
  3142                                              Header to be matched.
  3143                                            maxLength: 4096
  3144                                            minLength: 1
  3145                                            type: string
  3146                                        required:
  3147                                        - name
  3148                                        - value
  3149                                        type: object
  3150                                      maxItems: 16
  3151                                      type: array
  3152                                      x-kubernetes-list-map-keys:
  3153                                      - name
  3154                                      x-kubernetes-list-type: map
  3155                                    remove:
  3156                                      description: "Remove the given header(s) from
  3157                                        the HTTP request before the action. The value
  3158                                        of Remove is a list of HTTP header names.
  3159                                        Note that the header names are case-insensitive
  3160                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  3161                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  3162                                        my-header2: bar my-header3: baz \n Config:
  3163                                        remove: [\"my-header1\", \"my-header3\"] \n
  3164                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  3165                                      items:
  3166                                        type: string
  3167                                      maxItems: 16
  3168                                      type: array
  3169                                    set:
  3170                                      description: "Set overwrites the request with
  3171                                        the given header (name, value) before the
  3172                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  3173                                        foo \n Config: set: - name: \"my-header\"
  3174                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  3175                                        my-header: bar"
  3176                                      items:
  3177                                        description: HTTPHeader represents an HTTP
  3178                                          Header name and value as defined by RFC
  3179                                          7230.
  3180                                        properties:
  3181                                          name:
  3182                                            description: "Name is the name of the
  3183                                              HTTP Header to be matched. Name matching
  3184                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3185                                              \n If multiple entries specify equivalent
  3186                                              header names, the first entry with an
  3187                                              equivalent name MUST be considered for
  3188                                              a match. Subsequent entries with an
  3189                                              equivalent header name MUST be ignored.
  3190                                              Due to the case-insensitivity of header
  3191                                              names, \"foo\" and \"Foo\" are considered
  3192                                              equivalent."
  3193                                            maxLength: 256
  3194                                            minLength: 1
  3195                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3196                                            type: string
  3197                                          value:
  3198                                            description: Value is the value of HTTP
  3199                                              Header to be matched.
  3200                                            maxLength: 4096
  3201                                            minLength: 1
  3202                                            type: string
  3203                                        required:
  3204                                        - name
  3205                                        - value
  3206                                        type: object
  3207                                      maxItems: 16
  3208                                      type: array
  3209                                      x-kubernetes-list-map-keys:
  3210                                      - name
  3211                                      x-kubernetes-list-type: map
  3212                                  type: object
  3213                                type:
  3214                                  description: "Type identifies the type of filter
  3215                                    to apply. As with other API fields, types are
  3216                                    classified into three conformance levels: \n -
  3217                                    Core: Filter types and their corresponding configuration
  3218                                    defined by \"Support: Core\" in this package,
  3219                                    e.g. \"RequestHeaderModifier\". All implementations
  3220                                    must support core filters. \n - Extended: Filter
  3221                                    types and their corresponding configuration defined
  3222                                    by \"Support: Extended\" in this package, e.g.
  3223                                    \"RequestMirror\". Implementers are encouraged
  3224                                    to support extended filters. \n - Implementation-specific:
  3225                                    Filters that are defined and supported by specific
  3226                                    vendors. In the future, filters showing convergence
  3227                                    in behavior across multiple implementations will
  3228                                    be considered for inclusion in extended or core
  3229                                    conformance levels. Filter-specific configuration
  3230                                    for such filters is specified using the ExtensionRef
  3231                                    field. `Type` should be set to \"ExtensionRef\"
  3232                                    for custom filters. \n Implementers are encouraged
  3233                                    to define custom implementation types to extend
  3234                                    the core API with implementation-specific behavior.
  3235                                    \n If a reference to a custom filter type cannot
  3236                                    be resolved, the filter MUST NOT be skipped. Instead,
  3237                                    requests that would have been processed by that
  3238                                    filter MUST receive a HTTP error response. \n
  3239                                    Note that values may be added to this enum, implementations
  3240                                    must ensure that unknown values will not cause
  3241                                    a crash. \n Unknown values here must result in
  3242                                    the implementation setting the Accepted Condition
  3243                                    for the Route to `status: False`, with a Reason
  3244                                    of `UnsupportedValue`."
  3245                                  enum:
  3246                                  - RequestHeaderModifier
  3247                                  - ResponseHeaderModifier
  3248                                  - RequestRedirect
  3249                                  type: string
  3250                              required:
  3251                              - type
  3252                              type: object
  3253                            maxItems: 16
  3254                            type: array
  3255                        required:
  3256                        - name
  3257                        type: object
  3258                      maxItems: 16
  3259                      type: array
  3260                    filters:
  3261                      description: "Filters define the filters that are applied to
  3262                        requests that match this rule. \n The effects of ordering
  3263                        of multiple behaviors are currently unspecified. This can
  3264                        change in the future based on feedback during the alpha stage.
  3265                        \n Conformance-levels at this level are defined based on the
  3266                        type of filter: \n - ALL core filters MUST be supported by
  3267                        all implementations. - Implementers are encouraged to support
  3268                        extended filters. - Implementation-specific custom filters
  3269                        have no API guarantees across   implementations. \n Specifying
  3270                        a core filter multiple times has unspecified or custom conformance.
  3271                        \n All filters are expected to be compatible with each other
  3272                        except for the URLRewrite and RequestRedirect filters, which
  3273                        may not be combined. If an implementation can not support
  3274                        other combinations of filters, they must clearly document
  3275                        that limitation. In all cases where incompatible or unsupported
  3276                        filters are specified, implementations MUST add a warning
  3277                        condition to status. \n Support: Core"
  3278                      items:
  3279                        description: HTTPRouteFilter defines processing steps that
  3280                          must be completed during the request or response lifecycle.
  3281                          HTTPRouteFilters are meant as an extension point to express
  3282                          processing that may be done in Gateway implementations.
  3283                          Some examples include request or response modification,
  3284                          implementing authentication strategies, rate-limiting, and
  3285                          traffic shaping. API guarantee/conformance is defined based
  3286                          on the type of the filter.
  3287                        properties:
  3288                          requestHeaderModifier:
  3289                            description: "RequestHeaderModifier defines a schema for
  3290                              a filter that modifies request headers. \n Support:
  3291                              Core"
  3292                            properties:
  3293                              add:
  3294                                description: "Add adds the given header(s) (name,
  3295                                  value) to the request before the action. It appends
  3296                                  to any existing values associated with the header
  3297                                  name. \n Input:   GET /foo HTTP/1.1   my-header:
  3298                                  foo \n Config:   add:   - name: \"my-header\"     value:
  3299                                  \"bar\" \n Output:   GET /foo HTTP/1.1   my-header:
  3300                                  foo   my-header: bar"
  3301                                items:
  3302                                  description: HTTPHeader represents an HTTP Header
  3303                                    name and value as defined by RFC 7230.
  3304                                  properties:
  3305                                    name:
  3306                                      description: "Name is the name of the HTTP Header
  3307                                        to be matched. Name matching MUST be case
  3308                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3309                                        \n If multiple entries specify equivalent
  3310                                        header names, the first entry with an equivalent
  3311                                        name MUST be considered for a match. Subsequent
  3312                                        entries with an equivalent header name MUST
  3313                                        be ignored. Due to the case-insensitivity
  3314                                        of header names, \"foo\" and \"Foo\" are considered
  3315                                        equivalent."
  3316                                      maxLength: 256
  3317                                      minLength: 1
  3318                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3319                                      type: string
  3320                                    value:
  3321                                      description: Value is the value of HTTP Header
  3322                                        to be matched.
  3323                                      maxLength: 4096
  3324                                      minLength: 1
  3325                                      type: string
  3326                                  required:
  3327                                  - name
  3328                                  - value
  3329                                  type: object
  3330                                maxItems: 16
  3331                                type: array
  3332                                x-kubernetes-list-map-keys:
  3333                                - name
  3334                                x-kubernetes-list-type: map
  3335                              remove:
  3336                                description: "Remove the given header(s) from the
  3337                                  HTTP request before the action. The value of Remove
  3338                                  is a list of HTTP header names. Note that the header
  3339                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  3340                                  \n Input:   GET /foo HTTP/1.1   my-header1: foo
  3341                                  \  my-header2: bar   my-header3: baz \n Config:
  3342                                  \  remove: [\"my-header1\", \"my-header3\"] \n Output:
  3343                                  \  GET /foo HTTP/1.1   my-header2: bar"
  3344                                items:
  3345                                  type: string
  3346                                maxItems: 16
  3347                                type: array
  3348                              set:
  3349                                description: "Set overwrites the request with the
  3350                                  given header (name, value) before the action. \n
  3351                                  Input:   GET /foo HTTP/1.1   my-header: foo \n Config:
  3352                                  \  set:   - name: \"my-header\"     value: \"bar\"
  3353                                  \n Output:   GET /foo HTTP/1.1   my-header: bar"
  3354                                items:
  3355                                  description: HTTPHeader represents an HTTP Header
  3356                                    name and value as defined by RFC 7230.
  3357                                  properties:
  3358                                    name:
  3359                                      description: "Name is the name of the HTTP Header
  3360                                        to be matched. Name matching MUST be case
  3361                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3362                                        \n If multiple entries specify equivalent
  3363                                        header names, the first entry with an equivalent
  3364                                        name MUST be considered for a match. Subsequent
  3365                                        entries with an equivalent header name MUST
  3366                                        be ignored. Due to the case-insensitivity
  3367                                        of header names, \"foo\" and \"Foo\" are considered
  3368                                        equivalent."
  3369                                      maxLength: 256
  3370                                      minLength: 1
  3371                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3372                                      type: string
  3373                                    value:
  3374                                      description: Value is the value of HTTP Header
  3375                                        to be matched.
  3376                                      maxLength: 4096
  3377                                      minLength: 1
  3378                                      type: string
  3379                                  required:
  3380                                  - name
  3381                                  - value
  3382                                  type: object
  3383                                maxItems: 16
  3384                                type: array
  3385                                x-kubernetes-list-map-keys:
  3386                                - name
  3387                                x-kubernetes-list-type: map
  3388                            type: object
  3389                          requestRedirect:
  3390                            description: "RequestRedirect defines a schema for a filter
  3391                              that responds to the request with an HTTP redirection.
  3392                              \n Support: Core"
  3393                            properties:
  3394                              hostname:
  3395                                description: "Hostname is the hostname to be used
  3396                                  in the value of the `Location` header in the response.
  3397                                  When empty, the hostname of the request is used.
  3398                                  \n Support: Core"
  3399                                maxLength: 253
  3400                                minLength: 1
  3401                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3402                                type: string
  3403                              path:
  3404                                description: "Path defines parameters used to
  3405                                  modify the path of the incoming request. The
  3406                                  modified path is then used to construct the
  3407                                  `Location` header. When empty, the request
  3408                                  path is used as-is. \n Support: Extended"
  3409                                properties:
  3410                                  replaceFullPath:
  3411                                    description: ReplaceFullPath specifies the
  3412                                      value with which to replace the full path
  3413                                      of a request during a rewrite or redirect.
  3414                                    maxLength: 1024
  3415                                    type: string
  3416                                  replacePrefixMatch:
  3417                                    description: "ReplacePrefixMatch specifies
  3418                                      the value with which to replace the prefix
  3419                                      match of a request during a rewrite or
  3420                                      redirect. For example, a request to \"/foo/bar\"
  3421                                      with a prefix match of \"/foo\" and a
  3422                                      ReplacePrefixMatch of \"/xyz\" would be
  3423                                      modified to \"/xyz/bar\". \n Note that
  3424                                      this matches the behavior of the PathPrefix
  3425                                      match type. This matches full path elements.
  3426                                      A path element refers to the list of labels
  3427                                      in the path split by the `/` separator.
  3428                                      When specified, a trailing `/` is ignored.
  3429                                      For example, the paths `/abc`, `/abc/`,
  3430                                      and `/abc/def` would all match the prefix
  3431                                      `/abc`, but the path `/abcd` would not.
  3432                                      \n Request Path | Prefix Match | Replace
  3433                                      Prefix | Modified Path -------------|--------------|----------------|----------
  3434                                      /foo/bar     | /foo         | /xyz           |
  3435                                      /xyz/bar /foo/bar     | /foo         |
  3436                                      /xyz/          | /xyz/bar /foo/bar     |
  3437                                      /foo/        | /xyz           | /xyz/bar
  3438                                      /foo/bar     | /foo/        | /xyz/          |
  3439                                      /xyz/bar /foo         | /foo         |
  3440                                      /xyz           | /xyz /foo/        | /foo
  3441                                      \        | /xyz           | /xyz/ /foo/bar
  3442                                      \    | /foo         | <empty string> |
  3443                                      /bar /foo/        | /foo         | <empty
  3444                                      string> | / /foo         | /foo         |
  3445                                      <empty string> | / /foo/        | /foo
  3446                                      \        | /              | / /foo         |
  3447                                      /foo         | /              | /"
  3448                                    maxLength: 1024
  3449                                    type: string
  3450                                  type:
  3451                                    description: "Type defines the type of path
  3452                                      modifier. Additional types may be added
  3453                                      in a future release of the API. \n Note
  3454                                      that values may be added to this enum,
  3455                                      implementations must ensure that unknown
  3456                                      values will not cause a crash. \n Unknown
  3457                                      values here must result in the implementation
  3458                                      setting the Accepted Condition for the
  3459                                      Route to `status: False`, with a Reason
  3460                                      of `UnsupportedValue`."
  3461                                    enum:
  3462                                    - ReplaceFullPath
  3463                                    - ReplacePrefixMatch
  3464                                    type: string
  3465                                required:
  3466                                - type
  3467                                type: object
  3468                              port:
  3469                                description: "Port is the port to be used in the value
  3470                                  of the `Location` header in the response. When empty,
  3471                                  port (if specified) of the request is used. \n Support:
  3472                                  Extended"
  3473                                format: int32
  3474                                maximum: 65535
  3475                                minimum: 1
  3476                                type: integer
  3477                              scheme:
  3478                                description: "Scheme is the scheme to be used in the
  3479                                  value of the `Location` header in the response.
  3480                                  When empty, the scheme of the request is used. \n
  3481                                  Support: Extended"
  3482                                enum:
  3483                                - http
  3484                                - https
  3485                                type: string
  3486                              statusCode:
  3487                                default: 302
  3488                                description: "StatusCode is the HTTP status code to
  3489                                  be used in response. \n Support: Core"
  3490                                enum:
  3491                                - 301
  3492                                - 302
  3493                                type: integer
  3494                            type: object
  3495                          type:
  3496                            description: "Type identifies the type of filter to apply.
  3497                              As with other API fields, types are classified into
  3498                              three conformance levels: \n - Core: Filter types and
  3499                              their corresponding configuration defined by   \"Support:
  3500                              Core\" in this package, e.g. \"RequestHeaderModifier\"."
  3501                            enum:
  3502                            - RequestHeaderModifier
  3503                            - RequestRedirect
  3504                            type: string
  3505                        required:
  3506                        - type
  3507                        type: object
  3508                      maxItems: 16
  3509                      type: array
  3510                    matches:
  3511                      default:
  3512                      - path:
  3513                          type: PathPrefix
  3514                          value: /
  3515                      description: "Matches define conditions used for matching the
  3516                        rule against incoming HTTP requests. Each match is independent,
  3517                        i.e. this rule will be matched if **any** one of the matches
  3518                        is satisfied. \n For example, take the following matches configuration:
  3519                        \n ``` matches: - path:     value: \"/foo\"   headers:   -
  3520                        name: \"version\"     value: \"v2\" - path:     value: \"/v2/foo\"
  3521                        ``` \n For a request to match against this rule, a request
  3522                        must satisfy EITHER of the two conditions: \n - path prefixed
  3523                        with `/foo` AND contains the header `version: v2` - path prefix
  3524                        of `/v2/foo` \n See the documentation for HTTPRouteMatch on
  3525                        how to specify multiple match conditions that should be ANDed
  3526                        together. \n If no matches are specified, the default is a
  3527                        prefix path match on \"/\", which has the effect of matching
  3528                        every HTTP request. \n Proxy or Load Balancer routing configuration
  3529                        generated from HTTPRoutes MUST prioritize rules based on the
  3530                        following criteria, continuing on ties. Precedence must be
  3531                        given to the the Rule with the largest number of: \n * Characters
  3532                        in a matching non-wildcard hostname. * Characters in a matching
  3533                        hostname. * Characters in a matching path. * Header matches.
  3534                        * Query param matches. \n If ties still exist across multiple
  3535                        Routes, matching precedence MUST be determined in order of
  3536                        the following criteria, continuing on ties: \n * The oldest
  3537                        Route based on creation timestamp. * The Route appearing first
  3538                        in alphabetical order by   \"{namespace}/{name}\". \n If ties
  3539                        still exist within the Route that has been given precedence,
  3540                        matching precedence MUST be granted to the first matching
  3541                        rule meeting the above criteria. \n When no rules matching
  3542                        a request have been successfully attached to the parent a
  3543                        request is coming from, a HTTP 404 status code MUST be returned."
  3544                      items:
  3545                        description: "HTTPRouteMatch defines the predicate used to
  3546                          match requests to a given action. Multiple match types are
  3547                          ANDed together, i.e. the match will evaluate to true only
  3548                          if all conditions are satisfied. \n For example, the match
  3549                          below will match a HTTP request only if its path starts
  3550                          with `/foo` AND it contains the `version: v1` header: \n
  3551                          ``` match:   path:     value: \"/foo\"   headers:   - name:
  3552                          \"version\"     value \"v1\" ```"
  3553                        properties:
  3554                          headers:
  3555                            description: Headers specifies HTTP request header matchers.
  3556                              Multiple match values are ANDed together, meaning, a
  3557                              request must match all the specified headers to select
  3558                              the route.
  3559                            items:
  3560                              description: HTTPHeaderMatch describes how to select
  3561                                a HTTP route by matching HTTP request headers.
  3562                              properties:
  3563                                name:
  3564                                  description: "Name is the name of the HTTP Header
  3565                                    to be matched. Name matching MUST be case insensitive.
  3566                                    (See https://tools.ietf.org/html/rfc7230#section-3.2).
  3567                                    \n If multiple entries specify equivalent header
  3568                                    names, only the first entry with an equivalent
  3569                                    name MUST be considered for a match. Subsequent
  3570                                    entries with an equivalent header name MUST be
  3571                                    ignored. Due to the case-insensitivity of header
  3572                                    names, \"foo\" and \"Foo\" are considered equivalent.
  3573                                    \n When a header is repeated in an HTTP request,
  3574                                    it is implementation-specific behavior as to how
  3575                                    this is represented. Generally, proxies should
  3576                                    follow the guidance from the RFC: https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2.2
  3577                                    regarding processing a repeated header, with special
  3578                                    handling for \"Set-Cookie\"."
  3579                                  maxLength: 256
  3580                                  minLength: 1
  3581                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  3582                                  type: string
  3583                                type:
  3584                                  default: Exact
  3585                                  description: "Type specifies how to match against
  3586                                    the value of the header. \n Support: Core (Exact)
  3587                                    \n Support: Custom (RegularExpression) \n Since
  3588                                    RegularExpression HeaderMatchType has custom conformance,
  3589                                    implementations can support POSIX, PCRE or any
  3590                                    other dialects of regular expressions. Please
  3591                                    read the implementation's documentation to determine
  3592                                    the supported dialect."
  3593                                  enum:
  3594                                  - Exact
  3595                                  - RegularExpression
  3596                                  type: string
  3597                                value:
  3598                                  description: Value is the value of HTTP Header to
  3599                                    be matched.
  3600                                  maxLength: 4096
  3601                                  minLength: 1
  3602                                  type: string
  3603                              required:
  3604                              - name
  3605                              - value
  3606                              type: object
  3607                            maxItems: 16
  3608                            type: array
  3609                            x-kubernetes-list-map-keys:
  3610                            - name
  3611                            x-kubernetes-list-type: map
  3612                          method:
  3613                            description: "Method specifies HTTP method matcher. When
  3614                              specified, this route will be matched only if the request
  3615                              has the specified method. \n Support: Extended"
  3616                            enum:
  3617                            - GET
  3618                            - HEAD
  3619                            - POST
  3620                            - PUT
  3621                            - DELETE
  3622                            - CONNECT
  3623                            - OPTIONS
  3624                            - TRACE
  3625                            - PATCH
  3626                            type: string
  3627                          path:
  3628                            default:
  3629                              type: PathPrefix
  3630                              value: /
  3631                            description: Path specifies a HTTP request path matcher.
  3632                              If this field is not specified, a default prefix match
  3633                              on the "/" path is provided.
  3634                            properties:
  3635                              type:
  3636                                default: PathPrefix
  3637                                description: "Type specifies how to match against
  3638                                  the path Value. \n Support: Core (Exact, PathPrefix)
  3639                                  \n Support: Custom (RegularExpression)"
  3640                                enum:
  3641                                - Exact
  3642                                - PathPrefix
  3643                                - RegularExpression
  3644                                type: string
  3645                              value:
  3646                                default: /
  3647                                description: Value of the HTTP path to match against.
  3648                                maxLength: 1024
  3649                                type: string
  3650                            type: object
  3651                          queryParams:
  3652                            description: QueryParams specifies HTTP query parameter
  3653                              matchers. Multiple match values are ANDed together,
  3654                              meaning, a request must match all the specified query
  3655                              parameters to select the route.
  3656                            items:
  3657                              description: HTTPQueryParamMatch describes how to select
  3658                                a HTTP route by matching HTTP query parameters.
  3659                              properties:
  3660                                name:
  3661                                  description: Name is the name of the HTTP query
  3662                                    param to be matched. This must be an exact string
  3663                                    match. (See https://tools.ietf.org/html/rfc7230#section-2.7.3).
  3664                                  maxLength: 256
  3665                                  minLength: 1
  3666                                  type: string
  3667                                type:
  3668                                  default: Exact
  3669                                  description: "Type specifies how to match against
  3670                                    the value of the query parameter. \n Support:
  3671                                    Extended (Exact) \n Support: Custom (RegularExpression)
  3672                                    \n Since RegularExpression QueryParamMatchType
  3673                                    has custom conformance, implementations can support
  3674                                    POSIX, PCRE or any other dialects of regular expressions.
  3675                                    Please read the implementation's documentation
  3676                                    to determine the supported dialect."
  3677                                  enum:
  3678                                  - Exact
  3679                                  - RegularExpression
  3680                                  type: string
  3681                                value:
  3682                                  description: Value is the value of HTTP query param
  3683                                    to be matched.
  3684                                  maxLength: 1024
  3685                                  minLength: 1
  3686                                  type: string
  3687                              required:
  3688                              - name
  3689                              - value
  3690                              type: object
  3691                            maxItems: 16
  3692                            type: array
  3693                            x-kubernetes-list-map-keys:
  3694                            - name
  3695                            x-kubernetes-list-type: map
  3696                        type: object
  3697                      maxItems: 8
  3698                      type: array
  3699                  type: object
  3700                maxItems: 16
  3701                type: array
  3702            type: object
  3703          status:
  3704            description: Status defines the current state of HTTPRoute.
  3705            properties:
  3706              parents:
  3707                description: "Parents is a list of parent resources (usually Gateways)
  3708                  that are associated with the route, and the status of the route
  3709                  with respect to each parent. When this route attaches to a parent,
  3710                  the controller that manages the parent must add an entry to this
  3711                  list when the controller first sees the route and should update
  3712                  the entry as appropriate when the route or gateway is modified.
  3713                  \n Note that parent references that cannot be resolved by an implementation
  3714                  of this API will not be added to this list. Implementations of this
  3715                  API can only populate Route status for the Gateways/parent resources
  3716                  they are responsible for. \n A maximum of 32 Gateways will be represented
  3717                  in this list. An empty list means the route has not been attached
  3718                  to any Gateway."
  3719                items:
  3720                  description: RouteParentStatus describes the status of a route with
  3721                    respect to an associated Parent.
  3722                  properties:
  3723                    conditions:
  3724                      description: "Conditions describes the status of the route with
  3725                        respect to the Gateway. Note that the route's availability
  3726                        is also subject to the Gateway's own status conditions and
  3727                        listener status. \n If the Route's ParentRef specifies an
  3728                        existing Gateway that supports Routes of this kind AND that
  3729                        Gateway's controller has sufficient access, then that Gateway's
  3730                        controller MUST set the \"Accepted\" condition on the Route,
  3731                        to indicate whether the route has been accepted or rejected
  3732                        by the Gateway, and why. \n A Route MUST be considered \"Accepted\"
  3733                        if at least one of the Route's rules is implemented by the
  3734                        Gateway. \n There are a number of cases where the \"Accepted\"
  3735                        condition may not be set due to lack of controller visibility,
  3736                        that includes when: \n * The Route refers to a non-existent
  3737                        parent. * The Route is of a type that the controller does
  3738                        not support. * The Route is in a namespace the the controller
  3739                        does not have access to."
  3740                      items:
  3741                        description: "Condition contains details for one aspect of
  3742                          the current state of this API Resource. --- This struct
  3743                          is intended for direct use as an array at the field path
  3744                          .status.conditions.  For example, type FooStatus struct{
  3745                          \    // Represents the observations of a foo's current state.
  3746                          \    // Known .status.conditions.type are: \"Available\",
  3747                          \"Progressing\", and \"Degraded\"     // +patchMergeKey=type
  3748                          \    // +patchStrategy=merge     // +listType=map     //
  3749                          +listMapKey=type     Conditions []metav1.Condition `json:\"conditions,omitempty\"
  3750                          patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"`
  3751                          \n     // other fields }"
  3752                        properties:
  3753                          lastTransitionTime:
  3754                            description: lastTransitionTime is the last time the condition
  3755                              transitioned from one status to another. This should
  3756                              be when the underlying condition changed.  If that is
  3757                              not known, then using the time when the API field changed
  3758                              is acceptable.
  3759                            format: date-time
  3760                            type: string
  3761                          message:
  3762                            description: message is a human readable message indicating
  3763                              details about the transition. This may be an empty string.
  3764                            maxLength: 32768
  3765                            type: string
  3766                          observedGeneration:
  3767                            description: observedGeneration represents the .metadata.generation
  3768                              that the condition was set based upon. For instance,
  3769                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
  3770                              is 9, the condition is out of date with respect to the
  3771                              current state of the instance.
  3772                            format: int64
  3773                            minimum: 0
  3774                            type: integer
  3775                          reason:
  3776                            description: reason contains a programmatic identifier
  3777                              indicating the reason for the condition's last transition.
  3778                              Producers of specific condition types may define expected
  3779                              values and meanings for this field, and whether the
  3780                              values are considered a guaranteed API. The value should
  3781                              be a CamelCase string. This field may not be empty.
  3782                            maxLength: 1024
  3783                            minLength: 1
  3784                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
  3785                            type: string
  3786                          status:
  3787                            description: status of the condition, one of True, False,
  3788                              Unknown.
  3789                            enum:
  3790                            - "True"
  3791                            - "False"
  3792                            - Unknown
  3793                            type: string
  3794                          type:
  3795                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
  3796                              --- Many .condition.type values are consistent across
  3797                              resources like Available, but because arbitrary conditions
  3798                              can be useful (see .node.status.conditions), the ability
  3799                              to deconflict is important. The regex it matches is
  3800                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
  3801                            maxLength: 316
  3802                            pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
  3803                            type: string
  3804                        required:
  3805                        - lastTransitionTime
  3806                        - message
  3807                        - reason
  3808                        - status
  3809                        - type
  3810                        type: object
  3811                      maxItems: 8
  3812                      minItems: 1
  3813                      type: array
  3814                      x-kubernetes-list-map-keys:
  3815                      - type
  3816                      x-kubernetes-list-type: map
  3817                    controllerName:
  3818                      description: "ControllerName is a domain/path string that indicates
  3819                        the name of the controller that wrote this status. This corresponds
  3820                        with the controllerName field on GatewayClass. \n Example:
  3821                        \"example.net/gateway-controller\". \n The format of this
  3822                        field is DOMAIN \"/\" PATH, where DOMAIN and PATH are valid
  3823                        Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names).
  3824                        \n Controllers MUST populate this field when writing status.
  3825                        Controllers should ensure that entries to status populated
  3826                        with their ControllerName are cleaned up when they are no
  3827                        longer necessary."
  3828                      maxLength: 253
  3829                      minLength: 1
  3830                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$
  3831                      type: string
  3832                    parentRef:
  3833                      description: ParentRef corresponds with a ParentRef in the spec
  3834                        that this RouteParentStatus struct describes the status of.
  3835                      properties:
  3836                        group:
  3837                          default: policy.linkerd.io
  3838                          description: "Group is the group of the referent. \n Support:
  3839                            Core"
  3840                          maxLength: 253
  3841                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3842                          type: string
  3843                        kind:
  3844                          default: Gateway
  3845                          description: "Kind is kind of the referent. \n Support:
  3846                            Core (Gateway) Support: Custom (Other Resources)"
  3847                          maxLength: 63
  3848                          minLength: 1
  3849                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  3850                          type: string
  3851                        name:
  3852                          description: "Name is the name of the referent. \n Support:
  3853                            Core"
  3854                          maxLength: 253
  3855                          minLength: 1
  3856                          type: string
  3857                        namespace:
  3858                          description: "Namespace is the namespace of the referent.
  3859                            When unspecified (or empty string), this refers to the
  3860                            local namespace of the Route. \n Support: Core"
  3861                          maxLength: 63
  3862                          minLength: 1
  3863                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  3864                          type: string
  3865                        port:
  3866                          description: "Port is the network port this Route targets.
  3867                            It can be interpreted differently based on the type of
  3868                            parent resource. \n When the parent resource is a Gateway,
  3869                            this targets all listeners listening on the specified
  3870                            port that also support this kind of Route(and select this
  3871                            Route). It's not recommended to set `Port` unless the
  3872                            networking behaviors specified in a Route must apply to
  3873                            a specific port as opposed to a listener(s) whose port(s)
  3874                            may be changed. When both Port and SectionName are specified,
  3875                            the name and port of the selected listener must match
  3876                            both specified values. \n Implementations MAY choose to
  3877                            support other parent resources. Implementations supporting
  3878                            other types of parent resources MUST clearly document
  3879                            how/if Port is interpreted. \n For the purpose of status,
  3880                            an attachment is considered successful as long as the
  3881                            parent resource accepts it partially. For example, Gateway
  3882                            listeners can restrict which Routes can attach to them
  3883                            by Route kind, namespace, or hostname. If 1 of 2 Gateway
  3884                            listeners accept attachment from the referencing Route,
  3885                            the Route MUST be considered successfully attached. If
  3886                            no Gateway listeners accept attachment from this Route,
  3887                            the Route MUST be considered detached from the Gateway.
  3888                            \n Support: Extended \n <gateway:experimental>"
  3889                          format: int32
  3890                          maximum: 65535
  3891                          minimum: 1
  3892                          type: integer
  3893                        sectionName:
  3894                          description: "SectionName is the name of a section within
  3895                            the target resource. In the following resources, SectionName
  3896                            is interpreted as the following: \n * Gateway: Listener
  3897                            Name. When both Port (experimental) and SectionName are
  3898                            specified, the name and port of the selected listener
  3899                            must match both specified values. \n Implementations MAY
  3900                            choose to support attaching Routes to other resources.
  3901                            If that is the case, they MUST clearly document how SectionName
  3902                            is interpreted. \n When unspecified (empty string), this
  3903                            will reference the entire resource. For the purpose of
  3904                            status, an attachment is considered successful if at least
  3905                            one section in the parent resource accepts it. For example,
  3906                            Gateway listeners can restrict which Routes can attach
  3907                            to them by Route kind, namespace, or hostname. If 1 of
  3908                            2 Gateway listeners accept attachment from the referencing
  3909                            Route, the Route MUST be considered successfully attached.
  3910                            If no Gateway listeners accept attachment from this Route,
  3911                            the Route MUST be considered detached from the Gateway.
  3912                            \n Support: Core"
  3913                          maxLength: 253
  3914                          minLength: 1
  3915                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  3916                          type: string
  3917                      required:
  3918                      - name
  3919                      type: object
  3920                  required:
  3921                  - controllerName
  3922                  - parentRef
  3923                  type: object
  3924                maxItems: 32
  3925                type: array
  3926            required:
  3927            - parents
  3928            type: object
  3929        required:
  3930        - spec
  3931        type: object
  3932    served: true
  3933    storage: false
  3934    subresources:
  3935      status: {}
  3936  - additionalPrinterColumns:
  3937    - jsonPath: .spec.hostnames
  3938      name: Hostnames
  3939      type: string
  3940    - jsonPath: .metadata.creationTimestamp
  3941      name: Age
  3942      type: date
  3943    name: v1beta3
  3944    schema:
  3945      openAPIV3Schema:
  3946        description: HTTPRoute provides a way to route HTTP requests. This includes
  3947          the capability to match requests by hostname, path, header, or query param.
  3948          Filters can be used to specify additional processing steps. Backends specify
  3949          where matching requests should be routed.
  3950        properties:
  3951          apiVersion:
  3952            description: 'APIVersion defines the versioned schema of this representation
  3953              of an object. Servers should convert recognized schemas to the latest
  3954              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
  3955            type: string
  3956          kind:
  3957            description: 'Kind is a string value representing the REST resource this
  3958              object represents. Servers may infer this from the endpoint the client
  3959              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
  3960            type: string
  3961          metadata:
  3962            type: object
  3963          spec:
  3964            description: Spec defines the desired state of HTTPRoute.
  3965            properties:
  3966              hostnames:
  3967                description: "Hostnames defines a set of hostname that should match
  3968                  against the HTTP Host header to select a HTTPRoute to process the
  3969                  request. This matches the RFC 1123 definition of a hostname with
  3970                  2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname may
  3971                  be prefixed with a wildcard label (`*.`). The wildcard    label
  3972                  must appear by itself as the first label. \n If a hostname is specified
  3973                  by both the Listener and HTTPRoute, there must be at least one intersecting
  3974                  hostname for the HTTPRoute to be attached to the Listener. For example:
  3975                  \n * A Listener with `test.example.com` as the hostname matches
  3976                  HTTPRoutes   that have either not specified any hostnames, or have
  3977                  specified at   least one of `test.example.com` or `*.example.com`.
  3978                  * A Listener with `*.example.com` as the hostname matches HTTPRoutes
  3979                  \  that have either not specified any hostnames or have specified
  3980                  at least   one hostname that matches the Listener hostname. For
  3981                  example,   `*.example.com`, `test.example.com`, and `foo.test.example.com`
  3982                  would   all match. On the other hand, `example.com` and `test.example.net`
  3983                  would   not match. \n Hostnames that are prefixed with a wildcard
  3984                  label (`*.`) are interpreted as a suffix match. That means that
  3985                  a match for `*.example.com` would match both `test.example.com`,
  3986                  and `foo.test.example.com`, but not `example.com`. \n If both the
  3987                  Listener and HTTPRoute have specified hostnames, any HTTPRoute hostnames
  3988                  that do not match the Listener hostname MUST be ignored. For example,
  3989                  if a Listener specified `*.example.com`, and the HTTPRoute specified
  3990                  `test.example.com` and `test.example.net`, `test.example.net` must
  3991                  not be considered for a match. \n If both the Listener and HTTPRoute
  3992                  have specified hostnames, and none match with the criteria above,
  3993                  then the HTTPRoute is not accepted. The implementation must raise
  3994                  an 'Accepted' Condition with a status of `False` in the corresponding
  3995                  RouteParentStatus. \n Support: Core"
  3996                items:
  3997                  description: "Hostname is the fully qualified domain name of a network
  3998                    host. This matches the RFC 1123 definition of a hostname with
  3999                    2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
  4000                    may be prefixed with a wildcard label (`*.`). The wildcard    label
  4001                    must appear by itself as the first label. \n Hostname can be \"precise\"
  4002                    which is a domain name without the terminating dot of a network
  4003                    host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
  4004                    name prefixed with a single wildcard label (e.g. `*.example.com`).
  4005                    \n Note that as per RFC1035 and RFC1123, a *label* must consist
  4006                    of lower case alphanumeric characters or '-', and must start and
  4007                    end with an alphanumeric character. No other punctuation is allowed."
  4008                  maxLength: 253
  4009                  minLength: 1
  4010                  pattern: ^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  4011                  type: string
  4012                maxItems: 16
  4013                type: array
  4014              parentRefs:
  4015                description: "ParentRefs references the resources (usually Gateways)
  4016                  that a Route wants to be attached to. Note that the referenced parent
  4017                  resource needs to allow this for the attachment to be complete.
  4018                  For Gateways, that means the Gateway needs to allow attachment from
  4019                  Routes of this kind and namespace. \n The only kind of parent resource
  4020                  with \"Core\" support is Gateway. This API may be extended in the
  4021                  future to support additional kinds of parent resources such as one
  4022                  of the route kinds. \n It is invalid to reference an identical parent
  4023                  more than once. It is valid to reference multiple distinct sections
  4024                  within the same parent resource, such as 2 Listeners within a Gateway.
  4025                  \n It is possible to separately reference multiple distinct objects
  4026                  that may be collapsed by an implementation. For example, some implementations
  4027                  may choose to merge compatible Gateway Listeners together. If that
  4028                  is the case, the list of routes attached to those resources should
  4029                  also be merged."
  4030                items:
  4031                  description: "ParentReference identifies an API object (usually
  4032                    a Gateway) that can be considered a parent of this resource (usually
  4033                    a route). The only kind of parent resource with \"Core\" support
  4034                    is Gateway. This API may be extended in the future to support
  4035                    additional kinds of parent resources, such as HTTPRoute. \n The
  4036                    API object must be valid in the cluster; the Group and Kind must
  4037                    be registered in the cluster for this reference to be valid."
  4038                  properties:
  4039                    group:
  4040                      default: policy.linkerd.io
  4041                      description: "Group is the group of the referent. \n Support:
  4042                        Core"
  4043                      maxLength: 253
  4044                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  4045                      type: string
  4046                    kind:
  4047                      default: Gateway
  4048                      description: "Kind is kind of the referent. \n Support: Core
  4049                        (Gateway) Support: Custom (Other Resources)"
  4050                      maxLength: 63
  4051                      minLength: 1
  4052                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  4053                      type: string
  4054                    name:
  4055                      description: "Name is the name of the referent. \n Support:
  4056                        Core"
  4057                      maxLength: 253
  4058                      minLength: 1
  4059                      type: string
  4060                    namespace:
  4061                      description: "Namespace is the namespace of the referent. When
  4062                        unspecified (or empty string), this refers to the local namespace
  4063                        of the Route. \n Support: Core"
  4064                      maxLength: 63
  4065                      minLength: 1
  4066                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  4067                      type: string
  4068                    port:
  4069                      description: "Port specifies the destination
  4070                        port number to use for this resource.
  4071                        Port is required when the referent is
  4072                        a Kubernetes Service. In this case, the
  4073                        port number is the service port number,
  4074                        not the target port. For other resources,
  4075                        destination port might be derived from
  4076                        the referent resource or this field. \n Support: Extended"
  4077                      format: int32
  4078                      maximum: 65535
  4079                      minimum: 1
  4080                      type: integer
  4081                    sectionName:
  4082                      description: "SectionName is the name of a section within the
  4083                        target resource. In the following resources, SectionName is
  4084                        interpreted as the following: \n * Gateway: Listener Name.
  4085                        When both Port (experimental) and SectionName are specified,
  4086                        the name and port of the selected listener must match both
  4087                        specified values. \n Implementations MAY choose to support
  4088                        attaching Routes to other resources. If that is the case,
  4089                        they MUST clearly document how SectionName is interpreted.
  4090                        \n When unspecified (empty string), this will reference the
  4091                        entire resource. For the purpose of status, an attachment
  4092                        is considered successful if at least one section in the parent
  4093                        resource accepts it. For example, Gateway listeners can restrict
  4094                        which Routes can attach to them by Route kind, namespace,
  4095                        or hostname. If 1 of 2 Gateway listeners accept attachment
  4096                        from the referencing Route, the Route MUST be considered successfully
  4097                        attached. If no Gateway listeners accept attachment from this
  4098                        Route, the Route MUST be considered detached from the Gateway.
  4099                        \n Support: Core"
  4100                      maxLength: 253
  4101                      minLength: 1
  4102                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  4103                      type: string
  4104                  required:
  4105                  - name
  4106                  type: object
  4107                maxItems: 32
  4108                type: array
  4109              rules:
  4110                default:
  4111                - matches:
  4112                  - path:
  4113                      type: PathPrefix
  4114                      value: /
  4115                description: Rules are a list of HTTP matchers, filters and actions.
  4116                items:
  4117                  description: HTTPRouteRule defines semantics for matching an HTTP
  4118                    request based on conditions (matches) and processing it (filters).
  4119                  properties:
  4120                    backendRefs:
  4121                      description: "BackendRefs defines the backend(s) where matching
  4122                        requests should be sent. \n Failure behavior here depends
  4123                        on how many BackendRefs are specified and how many are invalid.
  4124                        \n If *all* entries in BackendRefs are invalid, and there
  4125                        are also no filters specified in this route rule, *all* traffic
  4126                        which matches this rule MUST receive a 500 status code. \n
  4127                        See the HTTPBackendRef definition for the rules about what
  4128                        makes a single HTTPBackendRef invalid. \n When a HTTPBackendRef
  4129                        is invalid, 500 status codes MUST be returned for requests
  4130                        that would have otherwise been routed to an invalid backend.
  4131                        If multiple backends are specified, and some are invalid,
  4132                        the proportion of requests that would otherwise have been
  4133                        routed to an invalid backend MUST receive a 500 status code.
  4134                        \n For example, if two backends are specified with equal weights,
  4135                        and one is invalid, 50 percent of traffic must receive a 500.
  4136                        Implementations may choose how that 50 percent is determined.
  4137                        \n Support: Core for Kubernetes Service \n Support: Implementation-specific
  4138                        for any other resource \n Support for weight: Core"
  4139                      items:
  4140                        description: HTTPBackendRef defines how a HTTPRoute should
  4141                          forward an HTTP request.
  4142                        properties:
  4143                          group:
  4144                            default: ""
  4145                            description: Group is the group of the referent. For example,
  4146                              "gateway.networking.k8s.io". When unspecified or empty
  4147                              string, core API group is inferred.
  4148                            maxLength: 253
  4149                            pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  4150                            type: string
  4151                          kind:
  4152                            default: Service
  4153                            description: Kind is kind of the referent. For example
  4154                              "HTTPRoute" or "Service". Defaults to "Service" when
  4155                              not specified.
  4156                            maxLength: 63
  4157                            minLength: 1
  4158                            pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  4159                            type: string
  4160                          name:
  4161                            description: Name is the name of the referent.
  4162                            maxLength: 253
  4163                            minLength: 1
  4164                            type: string
  4165                          namespace:
  4166                            description: "Namespace is the namespace of the backend.
  4167                              When unspecified, the local namespace is inferred. \n
  4168                              Note that when a namespace is specified, a ReferenceGrant
  4169                              object is required in the referent namespace to allow
  4170                              that namespace's owner to accept the reference. See
  4171                              the ReferenceGrant documentation for details. \n Support:
  4172                              Core"
  4173                            maxLength: 63
  4174                            minLength: 1
  4175                            pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  4176                            type: string
  4177                          port:
  4178                            description: Port specifies the destination port number
  4179                              to use for this resource. Port is required when the
  4180                              referent is a Kubernetes Service. In this case, the
  4181                              port number is the service port number, not the target
  4182                              port. For other resources, destination port might be
  4183                              derived from the referent resource or this field.
  4184                            format: int32
  4185                            maximum: 65535
  4186                            minimum: 1
  4187                            type: integer
  4188                          weight:
  4189                            default: 1
  4190                            description: "Weight specifies the proportion of requests
  4191                              forwarded to the referenced backend. This is computed
  4192                              as weight/(sum of all weights in this BackendRefs list).
  4193                              For non-zero values, there may be some epsilon from
  4194                              the exact proportion defined here depending on the precision
  4195                              an implementation supports. Weight is not a percentage
  4196                              and the sum of weights does not need to equal 100. \n
  4197                              If only one backend is specified and it has a weight
  4198                              greater than 0, 100% of the traffic is forwarded to
  4199                              that backend. If weight is set to 0, no traffic should
  4200                              be forwarded for this entry. If unspecified, weight
  4201                              defaults to 1. \n Support for this field varies based
  4202                              on the context where used."
  4203                            format: int32
  4204                            maximum: 1000000
  4205                            minimum: 0
  4206                            type: integer
  4207                          filters:
  4208                            description: "Filters defined at this level should be
  4209                              executed if and only if the request is being forwarded
  4210                              to the backend defined here. \n Support: Implementation-specific
  4211                              (For broader support of filters, use the Filters field
  4212                              in HTTPRouteRule.)"
  4213                            items:
  4214                              description: HTTPRouteFilter defines processing steps
  4215                                that must be completed during the request or response
  4216                                lifecycle. HTTPRouteFilters are meant as an extension
  4217                                point to express processing that may be done in Gateway
  4218                                implementations. Some examples include request or
  4219                                response modification, implementing authentication
  4220                                strategies, rate-limiting, and traffic shaping. API
  4221                                guarantee/conformance is defined based on the type
  4222                                of the filter.
  4223                              properties:
  4224                                requestHeaderModifier:
  4225                                  description: "RequestHeaderModifier defines a schema
  4226                                    for a filter that modifies request headers. \n
  4227                                    Support: Core"
  4228                                  properties:
  4229                                    add:
  4230                                      description: "Add adds the given header(s) (name,
  4231                                        value) to the request before the action. It
  4232                                        appends to any existing values associated
  4233                                        with the header name. \n Input: GET /foo HTTP/1.1
  4234                                        my-header: foo \n Config: add: - name: \"my-header\"
  4235                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  4236                                        my-header: foo,bar,baz"
  4237                                      items:
  4238                                        description: HTTPHeader represents an HTTP
  4239                                          Header name and value as defined by RFC
  4240                                          7230.
  4241                                        properties:
  4242                                          name:
  4243                                            description: "Name is the name of the
  4244                                              HTTP Header to be matched. Name matching
  4245                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  4246                                              \n If multiple entries specify equivalent
  4247                                              header names, the first entry with an
  4248                                              equivalent name MUST be considered for
  4249                                              a match. Subsequent entries with an
  4250                                              equivalent header name MUST be ignored.
  4251                                              Due to the case-insensitivity of header
  4252                                              names, \"foo\" and \"Foo\" are considered
  4253                                              equivalent."
  4254                                            maxLength: 256
  4255                                            minLength: 1
  4256                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  4257                                            type: string
  4258                                          value:
  4259                                            description: Value is the value of HTTP
  4260                                              Header to be matched.
  4261                                            maxLength: 4096
  4262                                            minLength: 1
  4263                                            type: string
  4264                                        required:
  4265                                        - name
  4266                                        - value
  4267                                        type: object
  4268                                      maxItems: 16
  4269                                      type: array
  4270                                      x-kubernetes-list-map-keys:
  4271                                      - name
  4272                                      x-kubernetes-list-type: map
  4273                                    remove:
  4274                                      description: "Remove the given header(s) from
  4275                                        the HTTP request before the action. The value
  4276                                        of Remove is a list of HTTP header names.
  4277                                        Note that the header names are case-insensitive
  4278                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  4279                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  4280                                        my-header2: bar my-header3: baz \n Config:
  4281                                        remove: [\"my-header1\", \"my-header3\"] \n
  4282                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  4283                                      items:
  4284                                        type: string
  4285                                      maxItems: 16
  4286                                      type: array
  4287                                    set:
  4288                                      description: "Set overwrites the request with
  4289                                        the given header (name, value) before the
  4290                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  4291                                        foo \n Config: set: - name: \"my-header\"
  4292                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  4293                                        my-header: bar"
  4294                                      items:
  4295                                        description: HTTPHeader represents an HTTP
  4296                                          Header name and value as defined by RFC
  4297                                          7230.
  4298                                        properties:
  4299                                          name:
  4300                                            description: "Name is the name of the
  4301                                              HTTP Header to be matched. Name matching
  4302                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  4303                                              \n If multiple entries specify equivalent
  4304                                              header names, the first entry with an
  4305                                              equivalent name MUST be considered for
  4306                                              a match. Subsequent entries with an
  4307                                              equivalent header name MUST be ignored.
  4308                                              Due to the case-insensitivity of header
  4309                                              names, \"foo\" and \"Foo\" are considered
  4310                                              equivalent."
  4311                                            maxLength: 256
  4312                                            minLength: 1
  4313                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  4314                                            type: string
  4315                                          value:
  4316                                            description: Value is the value of HTTP
  4317                                              Header to be matched.
  4318                                            maxLength: 4096
  4319                                            minLength: 1
  4320                                            type: string
  4321                                        required:
  4322                                        - name
  4323                                        - value
  4324                                        type: object
  4325                                      maxItems: 16
  4326                                      type: array
  4327                                      x-kubernetes-list-map-keys:
  4328                                      - name
  4329                                      x-kubernetes-list-type: map
  4330                                  type: object
  4331                                requestRedirect:
  4332                                  description: "RequestRedirect defines a schema for
  4333                                    a filter that responds to the request with an
  4334                                    HTTP redirection. \n Support: Core"
  4335                                  properties:
  4336                                    hostname:
  4337                                      description: "Hostname is the hostname to be
  4338                                        used in the value of the `Location` header
  4339                                        in the response. When empty, the hostname
  4340                                        in the `Host` header of the request is used.
  4341                                        \n Support: Core"
  4342                                      maxLength: 253
  4343                                      minLength: 1
  4344                                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  4345                                      type: string
  4346                                    path:
  4347                                      description: "Path defines parameters used to
  4348                                        modify the path of the incoming request. The
  4349                                        modified path is then used to construct the
  4350                                        `Location` header. When empty, the request
  4351                                        path is used as-is. \n Support: Extended"
  4352                                      properties:
  4353                                        replaceFullPath:
  4354                                          description: ReplaceFullPath specifies the
  4355                                            value with which to replace the full path
  4356                                            of a request during a rewrite or redirect.
  4357                                          maxLength: 1024
  4358                                          type: string
  4359                                        replacePrefixMatch:
  4360                                          description: "ReplacePrefixMatch specifies
  4361                                            the value with which to replace the prefix
  4362                                            match of a request during a rewrite or
  4363                                            redirect. For example, a request to \"/foo/bar\"
  4364                                            with a prefix match of \"/foo\" and a
  4365                                            ReplacePrefixMatch of \"/xyz\" would be
  4366                                            modified to \"/xyz/bar\". \n Note that
  4367                                            this matches the behavior of the PathPrefix
  4368                                            match type. This matches full path elements.
  4369                                            A path element refers to the list of labels
  4370                                            in the path split by the `/` separator.
  4371                                            When specified, a trailing `/` is ignored.
  4372                                            For example, the paths `/abc`, `/abc/`,
  4373                                            and `/abc/def` would all match the prefix
  4374                                            `/abc`, but the path `/abcd` would not.
  4375                                            \n Request Path | Prefix Match | Replace
  4376                                            Prefix | Modified Path -------------|--------------|----------------|----------
  4377                                            /foo/bar     | /foo         | /xyz           |
  4378                                            /xyz/bar /foo/bar     | /foo         |
  4379                                            /xyz/          | /xyz/bar /foo/bar     |
  4380                                            /foo/        | /xyz           | /xyz/bar
  4381                                            /foo/bar     | /foo/        | /xyz/          |
  4382                                            /xyz/bar /foo         | /foo         |
  4383                                            /xyz           | /xyz /foo/        | /foo
  4384                                            \        | /xyz           | /xyz/ /foo/bar
  4385                                            \    | /foo         | <empty string> |
  4386                                            /bar /foo/        | /foo         | <empty
  4387                                            string> | / /foo         | /foo         |
  4388                                            <empty string> | / /foo/        | /foo
  4389                                            \        | /              | / /foo         |
  4390                                            /foo         | /              | /"
  4391                                          maxLength: 1024
  4392                                          type: string
  4393                                        type:
  4394                                          description: "Type defines the type of path
  4395                                            modifier. Additional types may be added
  4396                                            in a future release of the API. \n Note
  4397                                            that values may be added to this enum,
  4398                                            implementations must ensure that unknown
  4399                                            values will not cause a crash. \n Unknown
  4400                                            values here must result in the implementation
  4401                                            setting the Accepted Condition for the
  4402                                            Route to `status: False`, with a Reason
  4403                                            of `UnsupportedValue`."
  4404                                          enum:
  4405                                          - ReplaceFullPath
  4406                                          - ReplacePrefixMatch
  4407                                          type: string
  4408                                      required:
  4409                                      - type
  4410                                      type: object
  4411                                    port:
  4412                                      description: "Port is the port to be used in
  4413                                        the value of the `Location` header in the
  4414                                        response. \n If no port is specified, the
  4415                                        redirect port MUST be derived using the following
  4416                                        rules: \n * If redirect scheme is not-empty,
  4417                                        the redirect port MUST be the well-known port
  4418                                        associated with the redirect scheme. Specifically
  4419                                        \"http\" to port 80 and \"https\" to port
  4420                                        443. If the redirect scheme does not have
  4421                                        a well-known port, the listener port of the
  4422                                        Gateway SHOULD be used. * If redirect scheme
  4423                                        is empty, the redirect port MUST be the Gateway
  4424                                        Listener port. \n Implementations SHOULD NOT
  4425                                        add the port number in the 'Location' header
  4426                                        in the following cases: \n * A Location header
  4427                                        that will use HTTP (whether that is determined
  4428                                        via the Listener protocol or the Scheme field)
  4429                                        _and_ use port 80. * A Location header that
  4430                                        will use HTTPS (whether that is determined
  4431                                        via the Listener protocol or the Scheme field)
  4432                                        _and_ use port 443. \n Support: Extended"
  4433                                      format: int32
  4434                                      maximum: 65535
  4435                                      minimum: 1
  4436                                      type: integer
  4437                                    scheme:
  4438                                      description: "Scheme is the scheme to be used
  4439                                        in the value of the `Location` header in the
  4440                                        response. When empty, the scheme of the request
  4441                                        is used. \n Scheme redirects can affect the
  4442                                        port of the redirect, for more information,
  4443                                        refer to the documentation for the port field
  4444                                        of this filter. \n Note that values may be
  4445                                        added to this enum, implementations must ensure
  4446                                        that unknown values will not cause a crash.
  4447                                        \n Unknown values here must result in the
  4448                                        implementation setting the Accepted Condition
  4449                                        for the Route to `status: False`, with a Reason
  4450                                        of `UnsupportedValue`. \n Support: Extended"
  4451                                      enum:
  4452                                      - http
  4453                                      - https
  4454                                      type: string
  4455                                    statusCode:
  4456                                      default: 302
  4457                                      description: "StatusCode is the HTTP status
  4458                                        code to be used in response. \n Note that
  4459                                        values may be added to this enum, implementations
  4460                                        must ensure that unknown values will not cause
  4461                                        a crash. \n Unknown values here must result
  4462                                        in the implementation setting the Accepted
  4463                                        Condition for the Route to `status: False`,
  4464                                        with a Reason of `UnsupportedValue`. \n Support:
  4465                                        Core"
  4466                                      enum:
  4467                                      - 301
  4468                                      - 302
  4469                                      type: integer
  4470                                  type: object
  4471                                responseHeaderModifier:
  4472                                  description: "ResponseHeaderModifier defines a schema
  4473                                    for a filter that modifies response headers. \n
  4474                                    Support: Extended"
  4475                                  properties:
  4476                                    add:
  4477                                      description: "Add adds the given header(s) (name,
  4478                                        value) to the request before the action. It
  4479                                        appends to any existing values associated
  4480                                        with the header name. \n Input: GET /foo HTTP/1.1
  4481                                        my-header: foo \n Config: add: - name: \"my-header\"
  4482                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
  4483                                        my-header: foo,bar,baz"
  4484                                      items:
  4485                                        description: HTTPHeader represents an HTTP
  4486                                          Header name and value as defined by RFC
  4487                                          7230.
  4488                                        properties:
  4489                                          name:
  4490                                            description: "Name is the name of the
  4491                                              HTTP Header to be matched. Name matching
  4492                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  4493                                              \n If multiple entries specify equivalent
  4494                                              header names, the first entry with an
  4495                                              equivalent name MUST be considered for
  4496                                              a match. Subsequent entries with an
  4497                                              equivalent header name MUST be ignored.
  4498                                              Due to the case-insensitivity of header
  4499                                              names, \"foo\" and \"Foo\" are considered
  4500                                              equivalent."
  4501                                            maxLength: 256
  4502                                            minLength: 1
  4503                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  4504                                            type: string
  4505                                          value:
  4506                                            description: Value is the value of HTTP
  4507                                              Header to be matched.
  4508                                            maxLength: 4096
  4509                                            minLength: 1
  4510                                            type: string
  4511                                        required:
  4512                                        - name
  4513                                        - value
  4514                                        type: object
  4515                                      maxItems: 16
  4516                                      type: array
  4517                                      x-kubernetes-list-map-keys:
  4518                                      - name
  4519                                      x-kubernetes-list-type: map
  4520                                    remove:
  4521                                      description: "Remove the given header(s) from
  4522                                        the HTTP request before the action. The value
  4523                                        of Remove is a list of HTTP header names.
  4524                                        Note that the header names are case-insensitive
  4525                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  4526                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
  4527                                        my-header2: bar my-header3: baz \n Config:
  4528                                        remove: [\"my-header1\", \"my-header3\"] \n
  4529                                        Output: GET /foo HTTP/1.1 my-header2: bar"
  4530                                      items:
  4531                                        type: string
  4532                                      maxItems: 16
  4533                                      type: array
  4534                                    set:
  4535                                      description: "Set overwrites the request with
  4536                                        the given header (name, value) before the
  4537                                        action. \n Input: GET /foo HTTP/1.1 my-header:
  4538                                        foo \n Config: set: - name: \"my-header\"
  4539                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
  4540                                        my-header: bar"
  4541                                      items:
  4542                                        description: HTTPHeader represents an HTTP
  4543                                          Header name and value as defined by RFC
  4544                                          7230.
  4545                                        properties:
  4546                                          name:
  4547                                            description: "Name is the name of the
  4548                                              HTTP Header to be matched. Name matching
  4549                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  4550                                              \n If multiple entries specify equivalent
  4551                                              header names, the first entry with an
  4552                                              equivalent name MUST be considered for
  4553                                              a match. Subsequent entries with an
  4554                                              equivalent header name MUST be ignored.
  4555                                              Due to the case-insensitivity of header
  4556                                              names, \"foo\" and \"Foo\" are considered
  4557                                              equivalent."
  4558                                            maxLength: 256
  4559                                            minLength: 1
  4560                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  4561                                            type: string
  4562                                          value:
  4563                                            description: Value is the value of HTTP
  4564                                              Header to be matched.
  4565                                            maxLength: 4096
  4566                                            minLength: 1
  4567                                            type: string
  4568                                        required:
  4569                                        - name
  4570                                        - value
  4571                                        type: object
  4572                                      maxItems: 16
  4573                                      type: array
  4574                                      x-kubernetes-list-map-keys:
  4575                                      - name
  4576                                      x-kubernetes-list-type: map
  4577                                  type: object
  4578                                type:
  4579                                  description: "Type identifies the type of filter
  4580                                    to apply. As with other API fields, types are
  4581                                    classified into three conformance levels: \n -
  4582                                    Core: Filter types and their corresponding configuration
  4583                                    defined by \"Support: Core\" in this package,
  4584                                    e.g. \"RequestHeaderModifier\". All implementations
  4585                                    must support core filters. \n - Extended: Filter
  4586                                    types and their corresponding configuration defined
  4587                                    by \"Support: Extended\" in this package, e.g.
  4588                                    \"RequestMirror\". Implementers are encouraged
  4589                                    to support extended filters. \n - Implementation-specific:
  4590                                    Filters that are defined and supported by specific
  4591                                    vendors. In the future, filters showing convergence
  4592                                    in behavior across multiple implementations will
  4593                                    be considered for inclusion in extended or core
  4594                                    conformance levels. Filter-specific configuration
  4595                                    for such filters is specified using the ExtensionRef
  4596                                    field. `Type` should be set to \"ExtensionRef\"
  4597                                    for custom filters. \n Implementers are encouraged
  4598                                    to define custom implementation types to extend
  4599                                    the core API with implementation-specific behavior.
  4600                                    \n If a reference to a custom filter type cannot
  4601                                    be resolved, the filter MUST NOT be skipped. Instead,
  4602                                    requests that would have been processed by that
  4603                                    filter MUST receive a HTTP error response. \n
  4604                                    Note that values may be added to this enum, implementations
  4605                                    must ensure that unknown values will not cause
  4606                                    a crash. \n Unknown values here must result in
  4607                                    the implementation setting the Accepted Condition
  4608                                    for the Route to `status: False`, with a Reason
  4609                                    of `UnsupportedValue`."
  4610                                  enum:
  4611                                  - RequestHeaderModifier
  4612                                  - ResponseHeaderModifier
  4613                                  - RequestRedirect
  4614                                  type: string
  4615                              required:
  4616                              - type
  4617                              type: object
  4618                            maxItems: 16
  4619                            type: array
  4620                        required:
  4621                        - name
  4622                        type: object
  4623                      maxItems: 16
  4624                      type: array
  4625                    filters:
  4626                      description: "Filters define the filters that are applied to
  4627                        requests that match this rule. \n The effects of ordering
  4628                        of multiple behaviors are currently unspecified. This can
  4629                        change in the future based on feedback during the alpha stage.
  4630                        \n Conformance-levels at this level are defined based on the
  4631                        type of filter: \n - ALL core filters MUST be supported by
  4632                        all implementations. - Implementers are encouraged to support
  4633                        extended filters. - Implementation-specific custom filters
  4634                        have no API guarantees across   implementations. \n Specifying
  4635                        a core filter multiple times has unspecified or custom conformance.
  4636                        \n All filters are expected to be compatible with each other
  4637                        except for the URLRewrite and RequestRedirect filters, which
  4638                        may not be combined. If an implementation can not support
  4639                        other combinations of filters, they must clearly document
  4640                        that limitation. In all cases where incompatible or unsupported
  4641                        filters are specified, implementations MUST add a warning
  4642                        condition to status. \n Support: Core"
  4643                      items:
  4644                        description: HTTPRouteFilter defines processing steps that
  4645                          must be completed during the request or response lifecycle.
  4646                          HTTPRouteFilters are meant as an extension point to express
  4647                          processing that may be done in Gateway implementations.
  4648                          Some examples include request or response modification,
  4649                          implementing authentication strategies, rate-limiting, and
  4650                          traffic shaping. API guarantee/conformance is defined based
  4651                          on the type of the filter.
  4652                        properties:
  4653                          requestHeaderModifier:
  4654                            description: "RequestHeaderModifier defines a schema for
  4655                              a filter that modifies request headers. \n Support:
  4656                              Core"
  4657                            properties:
  4658                              add:
  4659                                description: "Add adds the given header(s) (name,
  4660                                  value) to the request before the action. It appends
  4661                                  to any existing values associated with the header
  4662                                  name. \n Input:   GET /foo HTTP/1.1   my-header:
  4663                                  foo \n Config:   add:   - name: \"my-header\"     value:
  4664                                  \"bar\" \n Output:   GET /foo HTTP/1.1   my-header:
  4665                                  foo   my-header: bar"
  4666                                items:
  4667                                  description: HTTPHeader represents an HTTP Header
  4668                                    name and value as defined by RFC 7230.
  4669                                  properties:
  4670                                    name:
  4671                                      description: "Name is the name of the HTTP Header
  4672                                        to be matched. Name matching MUST be case
  4673                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  4674                                        \n If multiple entries specify equivalent
  4675                                        header names, the first entry with an equivalent
  4676                                        name MUST be considered for a match. Subsequent
  4677                                        entries with an equivalent header name MUST
  4678                                        be ignored. Due to the case-insensitivity
  4679                                        of header names, \"foo\" and \"Foo\" are considered
  4680                                        equivalent."
  4681                                      maxLength: 256
  4682                                      minLength: 1
  4683                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  4684                                      type: string
  4685                                    value:
  4686                                      description: Value is the value of HTTP Header
  4687                                        to be matched.
  4688                                      maxLength: 4096
  4689                                      minLength: 1
  4690                                      type: string
  4691                                  required:
  4692                                  - name
  4693                                  - value
  4694                                  type: object
  4695                                maxItems: 16
  4696                                type: array
  4697                                x-kubernetes-list-map-keys:
  4698                                - name
  4699                                x-kubernetes-list-type: map
  4700                              remove:
  4701                                description: "Remove the given header(s) from the
  4702                                  HTTP request before the action. The value of Remove
  4703                                  is a list of HTTP header names. Note that the header
  4704                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  4705                                  \n Input:   GET /foo HTTP/1.1   my-header1: foo
  4706                                  \  my-header2: bar   my-header3: baz \n Config:
  4707                                  \  remove: [\"my-header1\", \"my-header3\"] \n Output:
  4708                                  \  GET /foo HTTP/1.1   my-header2: bar"
  4709                                items:
  4710                                  type: string
  4711                                maxItems: 16
  4712                                type: array
  4713                              set:
  4714                                description: "Set overwrites the request with the
  4715                                  given header (name, value) before the action. \n
  4716                                  Input:   GET /foo HTTP/1.1   my-header: foo \n Config:
  4717                                  \  set:   - name: \"my-header\"     value: \"bar\"
  4718                                  \n Output:   GET /foo HTTP/1.1   my-header: bar"
  4719                                items:
  4720                                  description: HTTPHeader represents an HTTP Header
  4721                                    name and value as defined by RFC 7230.
  4722                                  properties:
  4723                                    name:
  4724                                      description: "Name is the name of the HTTP Header
  4725                                        to be matched. Name matching MUST be case
  4726                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  4727                                        \n If multiple entries specify equivalent
  4728                                        header names, the first entry with an equivalent
  4729                                        name MUST be considered for a match. Subsequent
  4730                                        entries with an equivalent header name MUST
  4731                                        be ignored. Due to the case-insensitivity
  4732                                        of header names, \"foo\" and \"Foo\" are considered
  4733                                        equivalent."
  4734                                      maxLength: 256
  4735                                      minLength: 1
  4736                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  4737                                      type: string
  4738                                    value:
  4739                                      description: Value is the value of HTTP Header
  4740                                        to be matched.
  4741                                      maxLength: 4096
  4742                                      minLength: 1
  4743                                      type: string
  4744                                  required:
  4745                                  - name
  4746                                  - value
  4747                                  type: object
  4748                                maxItems: 16
  4749                                type: array
  4750                                x-kubernetes-list-map-keys:
  4751                                - name
  4752                                x-kubernetes-list-type: map
  4753                            type: object
  4754                          requestRedirect:
  4755                            description: "RequestRedirect defines a schema for a filter
  4756                              that responds to the request with an HTTP redirection.
  4757                              \n Support: Core"
  4758                            properties:
  4759                              hostname:
  4760                                description: "Hostname is the hostname to be used
  4761                                  in the value of the `Location` header in the response.
  4762                                  When empty, the hostname of the request is used.
  4763                                  \n Support: Core"
  4764                                maxLength: 253
  4765                                minLength: 1
  4766                                pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  4767                                type: string
  4768                              path:
  4769                                description: "Path defines parameters used to
  4770                                  modify the path of the incoming request. The
  4771                                  modified path is then used to construct the
  4772                                  `Location` header. When empty, the request
  4773                                  path is used as-is. \n Support: Extended"
  4774                                properties:
  4775                                  replaceFullPath:
  4776                                    description: ReplaceFullPath specifies the
  4777                                      value with which to replace the full path
  4778                                      of a request during a rewrite or redirect.
  4779                                    maxLength: 1024
  4780                                    type: string
  4781                                  replacePrefixMatch:
  4782                                    description: "ReplacePrefixMatch specifies
  4783                                      the value with which to replace the prefix
  4784                                      match of a request during a rewrite or
  4785                                      redirect. For example, a request to \"/foo/bar\"
  4786                                      with a prefix match of \"/foo\" and a
  4787                                      ReplacePrefixMatch of \"/xyz\" would be
  4788                                      modified to \"/xyz/bar\". \n Note that
  4789                                      this matches the behavior of the PathPrefix
  4790                                      match type. This matches full path elements.
  4791                                      A path element refers to the list of labels
  4792                                      in the path split by the `/` separator.
  4793                                      When specified, a trailing `/` is ignored.
  4794                                      For example, the paths `/abc`, `/abc/`,
  4795                                      and `/abc/def` would all match the prefix
  4796                                      `/abc`, but the path `/abcd` would not.
  4797                                      \n Request Path | Prefix Match | Replace
  4798                                      Prefix | Modified Path -------------|--------------|----------------|----------
  4799                                      /foo/bar     | /foo         | /xyz           |
  4800                                      /xyz/bar /foo/bar     | /foo         |
  4801                                      /xyz/          | /xyz/bar /foo/bar     |
  4802                                      /foo/        | /xyz           | /xyz/bar
  4803                                      /foo/bar     | /foo/        | /xyz/          |
  4804                                      /xyz/bar /foo         | /foo         |
  4805                                      /xyz           | /xyz /foo/        | /foo
  4806                                      \        | /xyz           | /xyz/ /foo/bar
  4807                                      \    | /foo         | <empty string> |
  4808                                      /bar /foo/        | /foo         | <empty
  4809                                      string> | / /foo         | /foo         |
  4810                                      <empty string> | / /foo/        | /foo
  4811                                      \        | /              | / /foo         |
  4812                                      /foo         | /              | /"
  4813                                    maxLength: 1024
  4814                                    type: string
  4815                                  type:
  4816                                    description: "Type defines the type of path
  4817                                      modifier. Additional types may be added
  4818                                      in a future release of the API. \n Note
  4819                                      that values may be added to this enum,
  4820                                      implementations must ensure that unknown
  4821                                      values will not cause a crash. \n Unknown
  4822                                      values here must result in the implementation
  4823                                      setting the Accepted Condition for the
  4824                                      Route to `status: False`, with a Reason
  4825                                      of `UnsupportedValue`."
  4826                                    enum:
  4827                                    - ReplaceFullPath
  4828                                    - ReplacePrefixMatch
  4829                                    type: string
  4830                                required:
  4831                                - type
  4832                                type: object
  4833                              port:
  4834                                description: "Port is the port to be used in the value
  4835                                  of the `Location` header in the response. When empty,
  4836                                  port (if specified) of the request is used. \n Support:
  4837                                  Extended"
  4838                                format: int32
  4839                                maximum: 65535
  4840                                minimum: 1
  4841                                type: integer
  4842                              scheme:
  4843                                description: "Scheme is the scheme to be used in the
  4844                                  value of the `Location` header in the response.
  4845                                  When empty, the scheme of the request is used. \n
  4846                                  Support: Extended"
  4847                                enum:
  4848                                - http
  4849                                - https
  4850                                type: string
  4851                              statusCode:
  4852                                default: 302
  4853                                description: "StatusCode is the HTTP status code to
  4854                                  be used in response. \n Support: Core"
  4855                                enum:
  4856                                - 301
  4857                                - 302
  4858                                type: integer
  4859                            type: object
  4860                          type:
  4861                            description: "Type identifies the type of filter to apply.
  4862                              As with other API fields, types are classified into
  4863                              three conformance levels: \n - Core: Filter types and
  4864                              their corresponding configuration defined by   \"Support:
  4865                              Core\" in this package, e.g. \"RequestHeaderModifier\"."
  4866                            enum:
  4867                            - RequestHeaderModifier
  4868                            - RequestRedirect
  4869                            type: string
  4870                        required:
  4871                        - type
  4872                        type: object
  4873                      maxItems: 16
  4874                      type: array
  4875                    matches:
  4876                      default:
  4877                      - path:
  4878                          type: PathPrefix
  4879                          value: /
  4880                      description: "Matches define conditions used for matching the
  4881                        rule against incoming HTTP requests. Each match is independent,
  4882                        i.e. this rule will be matched if **any** one of the matches
  4883                        is satisfied. \n For example, take the following matches configuration:
  4884                        \n ``` matches: - path:     value: \"/foo\"   headers:   -
  4885                        name: \"version\"     value: \"v2\" - path:     value: \"/v2/foo\"
  4886                        ``` \n For a request to match against this rule, a request
  4887                        must satisfy EITHER of the two conditions: \n - path prefixed
  4888                        with `/foo` AND contains the header `version: v2` - path prefix
  4889                        of `/v2/foo` \n See the documentation for HTTPRouteMatch on
  4890                        how to specify multiple match conditions that should be ANDed
  4891                        together. \n If no matches are specified, the default is a
  4892                        prefix path match on \"/\", which has the effect of matching
  4893                        every HTTP request. \n Proxy or Load Balancer routing configuration
  4894                        generated from HTTPRoutes MUST prioritize rules based on the
  4895                        following criteria, continuing on ties. Precedence must be
  4896                        given to the the Rule with the largest number of: \n * Characters
  4897                        in a matching non-wildcard hostname. * Characters in a matching
  4898                        hostname. * Characters in a matching path. * Header matches.
  4899                        * Query param matches. \n If ties still exist across multiple
  4900                        Routes, matching precedence MUST be determined in order of
  4901                        the following criteria, continuing on ties: \n * The oldest
  4902                        Route based on creation timestamp. * The Route appearing first
  4903                        in alphabetical order by   \"{namespace}/{name}\". \n If ties
  4904                        still exist within the Route that has been given precedence,
  4905                        matching precedence MUST be granted to the first matching
  4906                        rule meeting the above criteria. \n When no rules matching
  4907                        a request have been successfully attached to the parent a
  4908                        request is coming from, a HTTP 404 status code MUST be returned."
  4909                      items:
  4910                        description: "HTTPRouteMatch defines the predicate used to
  4911                          match requests to a given action. Multiple match types are
  4912                          ANDed together, i.e. the match will evaluate to true only
  4913                          if all conditions are satisfied. \n For example, the match
  4914                          below will match a HTTP request only if its path starts
  4915                          with `/foo` AND it contains the `version: v1` header: \n
  4916                          ``` match:   path:     value: \"/foo\"   headers:   - name:
  4917                          \"version\"     value \"v1\" ```"
  4918                        properties:
  4919                          headers:
  4920                            description: Headers specifies HTTP request header matchers.
  4921                              Multiple match values are ANDed together, meaning, a
  4922                              request must match all the specified headers to select
  4923                              the route.
  4924                            items:
  4925                              description: HTTPHeaderMatch describes how to select
  4926                                a HTTP route by matching HTTP request headers.
  4927                              properties:
  4928                                name:
  4929                                  description: "Name is the name of the HTTP Header
  4930                                    to be matched. Name matching MUST be case insensitive.
  4931                                    (See https://tools.ietf.org/html/rfc7230#section-3.2).
  4932                                    \n If multiple entries specify equivalent header
  4933                                    names, only the first entry with an equivalent
  4934                                    name MUST be considered for a match. Subsequent
  4935                                    entries with an equivalent header name MUST be
  4936                                    ignored. Due to the case-insensitivity of header
  4937                                    names, \"foo\" and \"Foo\" are considered equivalent.
  4938                                    \n When a header is repeated in an HTTP request,
  4939                                    it is implementation-specific behavior as to how
  4940                                    this is represented. Generally, proxies should
  4941                                    follow the guidance from the RFC: https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2.2
  4942                                    regarding processing a repeated header, with special
  4943                                    handling for \"Set-Cookie\"."
  4944                                  maxLength: 256
  4945                                  minLength: 1
  4946                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  4947                                  type: string
  4948                                type:
  4949                                  default: Exact
  4950                                  description: "Type specifies how to match against
  4951                                    the value of the header. \n Support: Core (Exact)
  4952                                    \n Support: Custom (RegularExpression) \n Since
  4953                                    RegularExpression HeaderMatchType has custom conformance,
  4954                                    implementations can support POSIX, PCRE or any
  4955                                    other dialects of regular expressions. Please
  4956                                    read the implementation's documentation to determine
  4957                                    the supported dialect."
  4958                                  enum:
  4959                                  - Exact
  4960                                  - RegularExpression
  4961                                  type: string
  4962                                value:
  4963                                  description: Value is the value of HTTP Header to
  4964                                    be matched.
  4965                                  maxLength: 4096
  4966                                  minLength: 1
  4967                                  type: string
  4968                              required:
  4969                              - name
  4970                              - value
  4971                              type: object
  4972                            maxItems: 16
  4973                            type: array
  4974                            x-kubernetes-list-map-keys:
  4975                            - name
  4976                            x-kubernetes-list-type: map
  4977                          method:
  4978                            description: "Method specifies HTTP method matcher. When
  4979                              specified, this route will be matched only if the request
  4980                              has the specified method. \n Support: Extended"
  4981                            enum:
  4982                            - GET
  4983                            - HEAD
  4984                            - POST
  4985                            - PUT
  4986                            - DELETE
  4987                            - CONNECT
  4988                            - OPTIONS
  4989                            - TRACE
  4990                            - PATCH
  4991                            type: string
  4992                          path:
  4993                            default:
  4994                              type: PathPrefix
  4995                              value: /
  4996                            description: Path specifies a HTTP request path matcher.
  4997                              If this field is not specified, a default prefix match
  4998                              on the "/" path is provided.
  4999                            properties:
  5000                              type:
  5001                                default: PathPrefix
  5002                                description: "Type specifies how to match against
  5003                                  the path Value. \n Support: Core (Exact, PathPrefix)
  5004                                  \n Support: Custom (RegularExpression)"
  5005                                enum:
  5006                                - Exact
  5007                                - PathPrefix
  5008                                - RegularExpression
  5009                                type: string
  5010                              value:
  5011                                default: /
  5012                                description: Value of the HTTP path to match against.
  5013                                maxLength: 1024
  5014                                type: string
  5015                            type: object
  5016                          queryParams:
  5017                            description: QueryParams specifies HTTP query parameter
  5018                              matchers. Multiple match values are ANDed together,
  5019                              meaning, a request must match all the specified query
  5020                              parameters to select the route.
  5021                            items:
  5022                              description: HTTPQueryParamMatch describes how to select
  5023                                a HTTP route by matching HTTP query parameters.
  5024                              properties:
  5025                                name:
  5026                                  description: Name is the name of the HTTP query
  5027                                    param to be matched. This must be an exact string
  5028                                    match. (See https://tools.ietf.org/html/rfc7230#section-2.7.3).
  5029                                  maxLength: 256
  5030                                  minLength: 1
  5031                                  type: string
  5032                                type:
  5033                                  default: Exact
  5034                                  description: "Type specifies how to match against
  5035                                    the value of the query parameter. \n Support:
  5036                                    Extended (Exact) \n Support: Custom (RegularExpression)
  5037                                    \n Since RegularExpression QueryParamMatchType
  5038                                    has custom conformance, implementations can support
  5039                                    POSIX, PCRE or any other dialects of regular expressions.
  5040                                    Please read the implementation's documentation
  5041                                    to determine the supported dialect."
  5042                                  enum:
  5043                                  - Exact
  5044                                  - RegularExpression
  5045                                  type: string
  5046                                value:
  5047                                  description: Value is the value of HTTP query param
  5048                                    to be matched.
  5049                                  maxLength: 1024
  5050                                  minLength: 1
  5051                                  type: string
  5052                              required:
  5053                              - name
  5054                              - value
  5055                              type: object
  5056                            maxItems: 16
  5057                            type: array
  5058                            x-kubernetes-list-map-keys:
  5059                            - name
  5060                            x-kubernetes-list-type: map
  5061                        type: object
  5062                      maxItems: 8
  5063                      type: array
  5064                    timeouts:
  5065                      description: "Timeouts defines the timeouts that can be configured
  5066                        for an HTTP request. \n Support: Core \n <gateway:experimental>"
  5067                      properties:
  5068                        backendRequest:
  5069                          description: "BackendRequest specifies a timeout for an
  5070                            individual request from the gateway to a backend service.
  5071                            Typically used in conjunction with automatic retries,
  5072                            if supported by an implementation. Default is the value
  5073                            of Request timeout. \n Support: Extended"
  5074                          format: duration
  5075                          type: string
  5076                        request:
  5077                          description: "Request specifies a timeout for responding
  5078                            to client HTTP requests, disabled by default. \n For example,
  5079                            the following rule will timeout if a client request is
  5080                            taking longer than 10 seconds to complete: \n ``` rules:
  5081                            - timeouts: request: 10s backendRefs: ... ``` \n Support:
  5082                            Core"
  5083                          format: duration
  5084                          type: string
  5085                      type: object
  5086                  type: object
  5087                maxItems: 16
  5088                type: array
  5089            type: object
  5090          status:
  5091            description: Status defines the current state of HTTPRoute.
  5092            properties:
  5093              parents:
  5094                description: "Parents is a list of parent resources (usually Gateways)
  5095                  that are associated with the route, and the status of the route
  5096                  with respect to each parent. When this route attaches to a parent,
  5097                  the controller that manages the parent must add an entry to this
  5098                  list when the controller first sees the route and should update
  5099                  the entry as appropriate when the route or gateway is modified.
  5100                  \n Note that parent references that cannot be resolved by an implementation
  5101                  of this API will not be added to this list. Implementations of this
  5102                  API can only populate Route status for the Gateways/parent resources
  5103                  they are responsible for. \n A maximum of 32 Gateways will be represented
  5104                  in this list. An empty list means the route has not been attached
  5105                  to any Gateway."
  5106                items:
  5107                  description: RouteParentStatus describes the status of a route with
  5108                    respect to an associated Parent.
  5109                  properties:
  5110                    conditions:
  5111                      description: "Conditions describes the status of the route with
  5112                        respect to the Gateway. Note that the route's availability
  5113                        is also subject to the Gateway's own status conditions and
  5114                        listener status. \n If the Route's ParentRef specifies an
  5115                        existing Gateway that supports Routes of this kind AND that
  5116                        Gateway's controller has sufficient access, then that Gateway's
  5117                        controller MUST set the \"Accepted\" condition on the Route,
  5118                        to indicate whether the route has been accepted or rejected
  5119                        by the Gateway, and why. \n A Route MUST be considered \"Accepted\"
  5120                        if at least one of the Route's rules is implemented by the
  5121                        Gateway. \n There are a number of cases where the \"Accepted\"
  5122                        condition may not be set due to lack of controller visibility,
  5123                        that includes when: \n * The Route refers to a non-existent
  5124                        parent. * The Route is of a type that the controller does
  5125                        not support. * The Route is in a namespace the the controller
  5126                        does not have access to."
  5127                      items:
  5128                        description: "Condition contains details for one aspect of
  5129                          the current state of this API Resource. --- This struct
  5130                          is intended for direct use as an array at the field path
  5131                          .status.conditions.  For example, type FooStatus struct{
  5132                          \    // Represents the observations of a foo's current state.
  5133                          \    // Known .status.conditions.type are: \"Available\",
  5134                          \"Progressing\", and \"Degraded\"     // +patchMergeKey=type
  5135                          \    // +patchStrategy=merge     // +listType=map     //
  5136                          +listMapKey=type     Conditions []metav1.Condition `json:\"conditions,omitempty\"
  5137                          patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"`
  5138                          \n     // other fields }"
  5139                        properties:
  5140                          lastTransitionTime:
  5141                            description: lastTransitionTime is the last time the condition
  5142                              transitioned from one status to another. This should
  5143                              be when the underlying condition changed.  If that is
  5144                              not known, then using the time when the API field changed
  5145                              is acceptable.
  5146                            format: date-time
  5147                            type: string
  5148                          message:
  5149                            description: message is a human readable message indicating
  5150                              details about the transition. This may be an empty string.
  5151                            maxLength: 32768
  5152                            type: string
  5153                          observedGeneration:
  5154                            description: observedGeneration represents the .metadata.generation
  5155                              that the condition was set based upon. For instance,
  5156                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
  5157                              is 9, the condition is out of date with respect to the
  5158                              current state of the instance.
  5159                            format: int64
  5160                            minimum: 0
  5161                            type: integer
  5162                          reason:
  5163                            description: reason contains a programmatic identifier
  5164                              indicating the reason for the condition's last transition.
  5165                              Producers of specific condition types may define expected
  5166                              values and meanings for this field, and whether the
  5167                              values are considered a guaranteed API. The value should
  5168                              be a CamelCase string. This field may not be empty.
  5169                            maxLength: 1024
  5170                            minLength: 1
  5171                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
  5172                            type: string
  5173                          status:
  5174                            description: status of the condition, one of True, False,
  5175                              Unknown.
  5176                            enum:
  5177                            - "True"
  5178                            - "False"
  5179                            - Unknown
  5180                            type: string
  5181                          type:
  5182                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
  5183                              --- Many .condition.type values are consistent across
  5184                              resources like Available, but because arbitrary conditions
  5185                              can be useful (see .node.status.conditions), the ability
  5186                              to deconflict is important. The regex it matches is
  5187                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
  5188                            maxLength: 316
  5189                            pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
  5190                            type: string
  5191                        required:
  5192                        - lastTransitionTime
  5193                        - message
  5194                        - reason
  5195                        - status
  5196                        - type
  5197                        type: object
  5198                      maxItems: 8
  5199                      minItems: 1
  5200                      type: array
  5201                      x-kubernetes-list-map-keys:
  5202                      - type
  5203                      x-kubernetes-list-type: map
  5204                    controllerName:
  5205                      description: "ControllerName is a domain/path string that indicates
  5206                        the name of the controller that wrote this status. This corresponds
  5207                        with the controllerName field on GatewayClass. \n Example:
  5208                        \"example.net/gateway-controller\". \n The format of this
  5209                        field is DOMAIN \"/\" PATH, where DOMAIN and PATH are valid
  5210                        Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names).
  5211                        \n Controllers MUST populate this field when writing status.
  5212                        Controllers should ensure that entries to status populated
  5213                        with their ControllerName are cleaned up when they are no
  5214                        longer necessary."
  5215                      maxLength: 253
  5216                      minLength: 1
  5217                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$
  5218                      type: string
  5219                    parentRef:
  5220                      description: ParentRef corresponds with a ParentRef in the spec
  5221                        that this RouteParentStatus struct describes the status of.
  5222                      properties:
  5223                        group:
  5224                          default: policy.linkerd.io
  5225                          description: "Group is the group of the referent. \n Support:
  5226                            Core"
  5227                          maxLength: 253
  5228                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  5229                          type: string
  5230                        kind:
  5231                          default: Gateway
  5232                          description: "Kind is kind of the referent. \n Support:
  5233                            Core (Gateway) Support: Custom (Other Resources)"
  5234                          maxLength: 63
  5235                          minLength: 1
  5236                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  5237                          type: string
  5238                        name:
  5239                          description: "Name is the name of the referent. \n Support:
  5240                            Core"
  5241                          maxLength: 253
  5242                          minLength: 1
  5243                          type: string
  5244                        namespace:
  5245                          description: "Namespace is the namespace of the referent.
  5246                            When unspecified (or empty string), this refers to the
  5247                            local namespace of the Route. \n Support: Core"
  5248                          maxLength: 63
  5249                          minLength: 1
  5250                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  5251                          type: string
  5252                        port:
  5253                          description: "Port is the network port this Route targets.
  5254                            It can be interpreted differently based on the type of
  5255                            parent resource. \n When the parent resource is a Gateway,
  5256                            this targets all listeners listening on the specified
  5257                            port that also support this kind of Route(and select this
  5258                            Route). It's not recommended to set `Port` unless the
  5259                            networking behaviors specified in a Route must apply to
  5260                            a specific port as opposed to a listener(s) whose port(s)
  5261                            may be changed. When both Port and SectionName are specified,
  5262                            the name and port of the selected listener must match
  5263                            both specified values. \n Implementations MAY choose to
  5264                            support other parent resources. Implementations supporting
  5265                            other types of parent resources MUST clearly document
  5266                            how/if Port is interpreted. \n For the purpose of status,
  5267                            an attachment is considered successful as long as the
  5268                            parent resource accepts it partially. For example, Gateway
  5269                            listeners can restrict which Routes can attach to them
  5270                            by Route kind, namespace, or hostname. If 1 of 2 Gateway
  5271                            listeners accept attachment from the referencing Route,
  5272                            the Route MUST be considered successfully attached. If
  5273                            no Gateway listeners accept attachment from this Route,
  5274                            the Route MUST be considered detached from the Gateway.
  5275                            \n Support: Extended \n <gateway:experimental>"
  5276                          format: int32
  5277                          maximum: 65535
  5278                          minimum: 1
  5279                          type: integer
  5280                        sectionName:
  5281                          description: "SectionName is the name of a section within
  5282                            the target resource. In the following resources, SectionName
  5283                            is interpreted as the following: \n * Gateway: Listener
  5284                            Name. When both Port (experimental) and SectionName are
  5285                            specified, the name and port of the selected listener
  5286                            must match both specified values. \n Implementations MAY
  5287                            choose to support attaching Routes to other resources.
  5288                            If that is the case, they MUST clearly document how SectionName
  5289                            is interpreted. \n When unspecified (empty string), this
  5290                            will reference the entire resource. For the purpose of
  5291                            status, an attachment is considered successful if at least
  5292                            one section in the parent resource accepts it. For example,
  5293                            Gateway listeners can restrict which Routes can attach
  5294                            to them by Route kind, namespace, or hostname. If 1 of
  5295                            2 Gateway listeners accept attachment from the referencing
  5296                            Route, the Route MUST be considered successfully attached.
  5297                            If no Gateway listeners accept attachment from this Route,
  5298                            the Route MUST be considered detached from the Gateway.
  5299                            \n Support: Core"
  5300                          maxLength: 253
  5301                          minLength: 1
  5302                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  5303                          type: string
  5304                      required:
  5305                      - name
  5306                      type: object
  5307                  required:
  5308                  - controllerName
  5309                  - parentRef
  5310                  type: object
  5311                maxItems: 32
  5312                type: array
  5313            required:
  5314            - parents
  5315            type: object
  5316        required:
  5317        - spec
  5318        type: object
  5319    served: true
  5320    storage: true
  5321    subresources:
  5322      status: {}
  5323status:
  5324  acceptedNames:
  5325    kind: ""
  5326    plural: ""
  5327  conditions: []
  5328  storedVersions: []

View as plain text