//  3. SIGTERM. We will drain, wait termination drain duration, then exit. This is the standard pod shutdown; SIGTERM arrives when pod shutdown starts.
//     If the pod's terminationGracePeriod is shorter than our drain duration (rare), we may be a SIGKILL.
//  4. /drain + SIGTERM. This is the shutdown when using Kubernetes native sidecars.
//     /drain is called when the pod shutdown starts. We start draining, forever.

//  limitations under the License.

package envoy

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"strings"

	"istio.io/istio/pkg/log"
)

// DrainListeners drains inbound listeners of Envoy so that inflight requests
// can gracefully finish and even continue making outbound calls as needed.
func DrainListeners(adminPort uint32, inboundonly bool, skipExit bool) error {
	var drainURL string

	}

	// Let all the established get request loops soak
	time.Sleep(5 * time.Second)

	// Tear down
	close(stopChan)

	// Let loops drain
	drained = make(chan struct{})
	go func() {
		defer close(drained)
		wg.Wait()
	}()

	select {
	case <-drained:
	case <-time.After(wait.ForeverTestTimeout):
		t.Fatal("timed out waiting for clients to complete")
	}

    }

    void stopped(EndPointQueue queue) {
        waiting.remove(queue);
        endpoints.remove(queue);
        queue.dispatch(new EndOfStream());
    }

    public void drain(Collection<InterHubMessage> drainTo) {
        drainTo.addAll(queue);
        queue.clear();
    }

    private void flush() {

Austin Clements <******@****.***> 1683216807 -0400

Robert Griesemer <******@****.***> 1662082688 -0700

	wp, ok := m.Load(value)
	if !ok {
		return
	}
	if wp.Strong() != nil {
		t.Errorf("value %v still referenced a handle (or tiny block?) ", value)
		return
	}
	t.Errorf("failed to drain internal maps of %v", value)

	requiredTerminations sync.WaitGroup
}

func (i *instance) Start(stop <-chan struct{}) error {
	shutdown := func() {
		close(i.done)
	}

	// First, drain all startup tasks and immediately return if any fail.
	for startupDone := false; !startupDone; {
		select {
		case next := <-i.components:
			t0 := time.Now()
			if err := next.task(stop); err != nil {

apiVersion: release-notes/v2
kind: feature
area: traffic-management
issue:
  - 34855
releaseNotes:
  - |
    **Added** support for envoy to track active connections during drain and quit if active connections become zero 
              instead of waiting for entire drain duration. This is disabled by default and can be enabled by setting

        if (result.isOverflow()) {
          // Not enough room in output buffer--drain it, creating a bigger buffer if necessary.
          startDraining(true);
          continue DRAINING;
        } else if (result.isUnderflow()) {
          // If encoder underflows, it means either:
          // a) the final flush() succeeded; next drain (then done)
          // b) we encoded all of the input; next flush