go p.handleUpstreamDeltaResponse(con)

	for {
		select {
		case err := <-con.upstreamError:
			return err
		case err := <-con.downstreamError:
			// On downstream error, we will return. This propagates the error to downstream envoy which will trigger reconnect
			return err
		case <-con.stopChan:
			log.Debugf("upstream stopped")
			return nil
		}
	}
}

    is enabled by default. This means SNI will be set automatically based on the downstream HTTP host/authority header if `DestinationRule` does not explicitly set the same.

            settingsFile << "include '$it'\n"
            file("${it}/build.gradle") << """
                apply plugin: 'java-library'
            """
            ['project1', 'project2'].each { downstream ->
                file("$downstream/build.gradle") << """
                    dependencies {
                        implementation project(":$it")
                    }
                """
            }
        }

        when:
        source impl: ["class A { \n}"]
        run "impl:${language.compileTaskName}"

        then:
        impl.recompiledClasses 'A', 'B', 'C'
    }

    def "recompiles downstream dependents of classes whose package-info changed"() {
        given:
        source api: ["""
            package annotations;
            import java.lang.annotation.*;
            @Retention(RetentionPolicy.RUNTIME)

See the License for the specific language governing permissions and
limitations under the License.
*/

// This file helps to detect whether we changed the interface of Listers.
// This is important for downstream projects who import the Listers to not
// breaking their codes.

package contract

import (
	"k8s.io/kubernetes/pkg/scheduler/framework"
)

var _ framework.NodeInfoLister = &nodeInfoListerContract{}

                             const QuantizationSpecs& quantization_specs,
                             const DebuggerConfig& debugger_config) {
  // Convert NCHW tensors to NHWC at along with extra optimizations as
  // downstream passes perform better optimizations when dealing with NHWC
  // formatted tensors.
  AddProcessNchwTensorPasses(pm);

  pm.addPass(CreateLiftQuantizableSpotsAsFunctionsPass(quantization_specs));

// WebSocket data frame. The primary structure for this tunneling is
// the TunnelingConnection. A lot of the other code in streamtunnel.go
// is for properly upgrading both the upstream SPDY connection and the
// downstream WebSocket connection before streaming begins.

import okio.Timeout

/**
 * Replicates a single upstream source into multiple downstream sources. Each downstream source
 * returns the same bytes as the upstream source. Downstream sources may read data either as it
 * is returned by upstream, or after the upstream source has been exhausted.
 *
 * As bytes are returned from upstream they are written to a local file. Downstream sources read
 * from this file as necessary.
 *

  `ECDHE-ECDSA-AES256-GCM-SHA384`, `ECDHE-RSA-AES256-GCM-SHA384`, and ECDH
  curves to `P-256`. These restrictions apply on the following data paths:

  * mTLS communication between Envoy proxies;
  * regular TLS on the downstream and the upstream of Envoy proxies (e.g. gateway);
  * Google gRPC side requests from Envoy proxies (e.g. Stackdriver extensions);
  * Istiod xDS server;
  * Istiod injection and validation webhook servers.

        // This is a no-op transform, however it ensures FilterChain executes full byte->string->byte sequence
        filterChain.add(s -> s);

        // Make the input string longer to ensure the downstream implementations would have to use a buffer
        // instead of converting the full string at once
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10000; i++) {