apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
releaseNotes:
  - |

    assertThat(statusLine.protocol).isEqualTo(Protocol.HTTP_1_1)
    assertThat(statusLine.code).isEqualTo(code)
  }

  @Test
  fun emptyMessage() {
    val version = 1
    val code = 503
    val statusLine = parse("HTTP/1.$version $code ")
    assertThat(statusLine.message).isEqualTo("")
    assertThat(statusLine.protocol).isEqualTo(Protocol.HTTP_1_1)
    assertThat(statusLine.code).isEqualTo(code)
  }

		testMetricEquals(metrics.ProxyHealthzTotal.WithLabelValues("503"), float64(hsTest.tracking503), t)
	}
	if hsTest.url == livezURL {
		testMetricEquals(metrics.ProxyLivezTotal.WithLabelValues("200"), float64(hsTest.tracking200), t)
		testMetricEquals(metrics.ProxyLivezTotal.WithLabelValues("503"), float64(hsTest.tracking503), t)
	}
}

					Attempts: 2,
					RetryOn:  "gateway-error,retriable-status-codes,503",
				},
			},
			assertFunc: func(g *WithT, policy *envoyroute.RetryPolicy) {
				g.Expect(policy).To(Not(BeNil()))
				g.Expect(policy.RetryOn).To(Equal("gateway-error,retriable-status-codes"))
				g.Expect(policy.RetriableStatusCodes).To(Equal([]uint32{503}))
			},
		},
		{
			name: "TestRetryOnWithWhitespace",

			svdata: FakeSVMapData{
				gvr: schema.GroupVersionResource{
					Group:    "core",
					Version:  "bar",
					Resource: "baz"},
				serverId: ""},
		},
		{
			desc:                 "503 if no endpoint fetched from lease",
			requestPath:          "/api/foo/bar",
			expectedStatus:       http.StatusServiceUnavailable,
			informerFinishedSync: true,
			svdata: FakeSVMapData{

					useGateway:      false,
				},

				// Set up an UpstreamCluster with a CredentialName when secret doesn't even exist in istio-system ns.
				// Secret fetching error at Gateway, results in a 503 response.
				{
					name:            "missing secret",
					statusCode:      http.StatusServiceUnavailable,
					credentialToUse: credNameMissing,
					useGateway:      false,
				},
			}

					expectedResponse: ingressutil.ExpectedResponse{
						StatusCode: http.StatusOK,
					},
				},
				// Mutual TLS origination from an unauthorized sidecar to https endpoint
				// This will result in a 503 with the UH flag because the cluster will
				// stay warming until a valid secret is sent.
				{
					name:            "unauthorized sidecar",
					credentialToUse: credNameGeneric,
					from:            apps.Ns1.B,

		} else {
			interfaceFound = true
		}
	}
	if !interfaceFound {
		return nil, errors.New("no available interface found")
	}

	// Wrap given handler to do additional
	// * return 503 (service unavailable) if the server in shutdown.
	wrappedHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// If server is in shutdown.
		if atomic.LoadUint32(&srv.inShutdown) != 0 {

			},
			// expected calls: NFNL_MSG_ACCT_GET
			netlinkCalls: 1,
		},
		{
			name:        "valid without padding",
			counterName: "metrics",
			counter:     &Counter{Name: "metrics", Packets: 12, Bytes: 503},
			handler: &fakeHandler{
				responses: [][][]byte{{{
					0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00,
					0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x00,
					0x0c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,

   *    has since been closed by the server.
   *  * A client timeout (HTTP 408).
   *  * A authorization challenge (HTTP 401 and 407) that is satisfied by the [Authenticator].
   *  * A retryable server failure (HTTP 503 with a `Retry-After: 0` response header).
   *  * A misdirected request (HTTP 421) on a coalesced connection.
   */
  open fun isOneShot(): Boolean = commonIsOneShot()

  companion object {
    /**