| {"id": "patchbench-java-real-0070", "repo": "grpc/grpc-java", "base_commit": "b16da37cab5407b8a5abf3353027aa21a1186725", "status": "verified", "verify_status": "verified", "error": null, "timing": {"setup": 5.2, "pre_test_0": 262.2, "pre_test_1": 71.3, "post_test_0": 240.7, "post_test_1": 215.5, "total": 795.5}, "test_cmds": ["./gradlew -Dorg.gradle.parallel=true -Dorg.gradle.jvmargs='-Xmx1g' -PskipAndroid=true -PskipCodegen=true -PerrorProne=false test --info --rerun-tasks"], "rebuild_cmds": [], "print_cmds": [], "f2p_pre_ok": true, "pre_detail": {"missing": 0, "wrong": [], "missing_ids": [], "parsed_count": 820}, "p2p_env_dropped_count": 7124, "f2p_post_ok": true, "p2p_post_ok": true, "post_detail": {"missing": 0, "wrong": [], "missing_ids": [], "parsed_count": 6271}, "raw_tail": "ide</div>\n<div id=\"summary\">\n<table>\n<tr>\n<td>\n<div class=\"summaryGroup\">\n<table>\n<tr>\n<td>\n<div class=\"infoBox\" id=\"tests\">\n<div class=\"counter\">4</div>\n<p>tests</p>\n</div>\n</td>\n<td>\n<div class=\"infoBox\" id=\"failures\">\n<div class=\"counter\">0</div>\n<p>failures</p>\n</div>\n</td>\n<td>\n<div class=\"infoBox\" id=\"ignored\">\n<div class=\"counter\">0</div>\n<p>ignored</p>\n</div>\n</td>\n<td>\n<div class=\"infoBox\" id=\"duration\">\n<div class=\"counter\">0.235s</div>\n<p>duration</p>\n</div>\n</td>\n</tr>\n</table>\n</div>\n</td>\n<td>\n<div class=\"infoBox success\" id=\"successRate\">\n<div class=\"percent\">100%</div>\n<p>successful</p>\n</div>\n</td>\n</tr>\n</table>\n</div>\n<div class=\"tab-container\">\n<ul class=\"tabLinks\">\n<li>\n<a href=\"#\">Classes</a>\n</li>\n</ul>\n<div class=\"tab\">\n<h2>Classes</h2>\n<table>\n<thead>\n<tr>\n<th>Class</th>\n<th>Tests</th>\n<th>Failures</th>\n<th>Ignored</th>\n<th>Duration</th>\n<th>Success rate</th>\n</tr>\n</thead>\n<tr>\n<td class=\"success\">\n<a href=\"../classes/io.grpc.override.OpenTelemetryContextStorageTest.html\">OpenTelemetryContextStorageTest</a>\n</td>\n<td>4</td>\n<td>0</td>\n<td>0</td>\n<td>0.235s</td>\n<td class=\"success\">100%</td>\n</tr>\n</table>\n</div>\n</div>\n<div id=\"footer\">\n<p>\n<div>\n<label class=\"hidden\" id=\"label-for-line-wrapping-toggle\" for=\"line-wrapping-toggle\">Wrap lines\n<input id=\"line-wrapping-toggle\" type=\"checkbox\" autocomplete=\"off\"/>\n</label>\n</div>Generated by \n<a href=\"https://www.gradle.org\">Gradle 8.14.3</a> at Sep 10, 2026, 8:17:39 PM</p>\n</div>\n</div>\n</body>\n</html>\n\n", "context_files": [{"path": "api/src/main/java/io/grpc/EquivalentAddressGroup.java", "content": "/*\n * Copyright 2015 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport com.google.common.base.Preconditions;\nimport java.lang.annotation.Documented;\nimport java.lang.annotation.Retention;\nimport java.lang.annotation.RetentionPolicy;\nimport java.net.SocketAddress;\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.List;\n\n/**\n * A group of {@link SocketAddress}es that are considered equivalent when channel makes connections.\n *\n * <p>Usually the addresses are addresses resolved from the same host name, and connecting to any of\n * them is equally sufficient. They do have order. An address appears earlier on the list is likely\n * to be tried earlier.\n */\n@ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/1770\")\npublic final class EquivalentAddressGroup {\n\n /**\n * The authority to be used when constructing Subchannels for this EquivalentAddressGroup.\n * However, if the channel has overridden authority via\n * {@link ManagedChannelBuilder#overrideAuthority(String)}, the transport will use the channel's\n * authority override.\n *\n * <p>The authority <strong>must</strong> be from a trusted source, because if the authority is\n * tampered with, RPCs may be sent to attackers which may leak sensitive user data. If the\n * authority was acquired by doing I/O, the communication must be authenticated (e.g., via TLS).\n * Recognize that the server that provided the authority can trivially impersonate the service.\n */\n @Attr\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/6138\")\n public static final Attributes.Key<String> ATTR_AUTHORITY_OVERRIDE =\n Attributes.Key.create(\"io.grpc.EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE\");\n /**\n * The name of the locality that this EquivalentAddressGroup is in.\n */\n public static final Attributes.Key<String> ATTR_LOCALITY_NAME =\n Attributes.Key.create(\"io.grpc.EquivalentAddressGroup.LOCALITY\");\n /**\n * The backend service associated with this EquivalentAddressGroup.\n */\n @Attr\n static final Attributes.Key<String> ATTR_BACKEND_SERVICE =\n Attributes.Key.create(\"io.grpc.EquivalentAddressGroup.BACKEND_SERVICE\");\n /**\n * Endpoint weight for load balancing purposes. While the type is Long, it must be a valid uint32.\n * Must not be zero. The weight is proportional to the other endpoints; if an endpoint's weight is\n * twice that of another endpoint, it is intended to receive twice the load.\n */\n @Attr\n static final Attributes.Key<Long> ATTR_WEIGHT =\n Attributes.Key.create(\"io.grpc.EquivalentAddressGroup.ATTR_WEIGHT\");\n\n private final List<SocketAddress> addrs;\n private final Attributes attrs;\n\n /**\n * {@link SocketAddress} docs say that the addresses are immutable, so we cache the hashCode.\n */\n private final int hashCode;\n\n /**\n * List constructor without {@link Attributes}.\n */\n public EquivalentAddressGroup(List<SocketAddress> addrs) {\n this(addrs, Attributes.EMPTY);\n }\n\n /**\n * List constructor with {@link Attributes}.\n */\n public EquivalentAddressGroup(List<SocketAddress> addrs, @Attr Attributes attrs) {\n Preconditions.checkArgument(!addrs.isEmpty(), \"addrs is empty\");\n this.addrs = Collections.unmodifiableList(new ArrayList<>(addrs));\n this.attrs = Preconditions.checkNotNull(attrs, \"attrs\");\n // Attributes may contain mutable objects, which means Attributes' hashCode may change over\n // time, thus we don't cache Attributes' hashCode.\n hashCode = this.addrs.hashCode();\n }\n\n /**\n * Singleton constructor without Attributes.\n */\n public EquivalentAddressGroup(SocketAddress addr) {\n this(addr, Attributes.EMPTY);\n }\n\n /**\n * Singleton constructor with Attributes.\n */\n public EquivalentAddressGroup(SocketAddress addr, @Attr Attributes attrs) {\n this(Collections.singletonList(addr), attrs);\n }\n\n /**\n * Returns an immutable list of the addresses.\n */\n public List<SocketAddress> getAddresses() {\n return addrs;\n }\n\n /**\n * Returns the attributes.\n */\n @Attr\n public Attributes getAttributes() {\n return attrs;\n }\n\n @Override\n public String toString() {\n // EquivalentAddressGroup is intended to contain a small number of addresses for the same\n // endpoint(e.g., IPv4/IPv6). Aggregating many groups into a single EquivalentAddressGroup\n // is no longer done, so this no longer needs summarization.\n return \"[\" + addrs + \"/\" + attrs + \"]\";\n }\n\n @Override\n public int hashCode() {\n // Avoids creating an iterator on the underlying array list.\n return hashCode;\n }\n\n /**\n * Returns true if the given object is also an {@link EquivalentAddressGroup} with an equal\n * address list and equal attribute values.\n *\n * <p>Note that if the attributes include mutable values, it is possible for two objects to be\n * considered equal at one point in time and not equal at another (due to concurrent mutation of\n * attribute values).\n */\n @Override\n public boolean equals(Object other) {\n if (this == other) {\n return true;\n }\n if (!(other instanceof EquivalentAddressGroup)) {\n return false;\n }\n EquivalentAddressGroup that = (EquivalentAddressGroup) other;\n if (addrs.size() != that.addrs.size()) {\n return false;\n }\n // Avoids creating an iterator on the underlying array list.\n for (int i = 0; i < addrs.size(); i++) {\n if (!addrs.get(i).equals(that.addrs.get(i))) {\n return false;\n }\n }\n if (!attrs.equals(that.attrs)) {\n return false;\n }\n return true;\n }\n\n /**\n * Annotation for {@link EquivalentAddressGroup}'s attributes. It follows the annotation semantics\n * defined by {@link Attributes}.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/4972\")\n @Retention(RetentionPolicy.SOURCE)\n @Documented\n public @interface Attr {}\n}\n"}, {"path": "api/src/main/java/io/grpc/InternalEquivalentAddressGroup.java", "content": "/*\n * Copyright 2026 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\n@Internal\npublic final class InternalEquivalentAddressGroup {\n private InternalEquivalentAddressGroup() {}\n\n /**\n * Endpoint weight for load balancing purposes. While the type is Long, it must be a valid uint32.\n * Must not be zero. The weight is proportional to the other endpoints; if an endpoint's weight is\n * twice that of another endpoint, it is intended to receive twice the load.\n */\n public static final Attributes.Key<Long> ATTR_WEIGHT = EquivalentAddressGroup.ATTR_WEIGHT;\n\n /**\n * The backend service associated with this EquivalentAddressGroup.\n */\n public static final Attributes.Key<String> ATTR_BACKEND_SERVICE =\n EquivalentAddressGroup.ATTR_BACKEND_SERVICE;\n}\n"}, {"path": "api/src/main/java/io/grpc/Attributes.java", "content": "/*\n * Copyright 2015 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport static com.google.common.base.Preconditions.checkNotNull;\n\nimport com.google.common.base.Objects;\nimport java.util.Collections;\nimport java.util.IdentityHashMap;\nimport java.util.Map;\nimport java.util.Set;\nimport javax.annotation.Nullable;\nimport javax.annotation.concurrent.Immutable;\n\n/**\n * An immutable type-safe container of attributes.\n *\n * <h3>Annotation semantics</h3>\n *\n * <p>As a convention, annotations such as {@link Grpc.TransportAttr} is defined to associate\n * attribute {@link Key}s and their propagation paths. The annotation may be applied to a {@code\n * Key} definition field, a method that returns {@link Attributes}, or a variable of type {@link\n * Attributes}, to indicate that the annotated {@link Attributes} objects may contain the annotated\n * {@code Key}.\n *\n * <p>Javadoc users may click \"USE\" on the navigation bars of the annotation's javadoc page to view\n * references of such annotation.\n *\n * @since 1.13.0\n */\n@ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/1764\")\n@Immutable\npublic final class Attributes {\n\n private final IdentityHashMap<Key<?>, Object> data;\n\n private static final IdentityHashMap<Key<?>, Object> EMPTY_MAP =\n new IdentityHashMap<Key<?>, Object>();\n public static final Attributes EMPTY = new Attributes(EMPTY_MAP);\n\n private Attributes(IdentityHashMap<Key<?>, Object> data) {\n assert data != null;\n this.data = data;\n }\n\n /**\n * Gets the value for the key, or {@code null} if it's not present.\n */\n @SuppressWarnings(\"unchecked\")\n @Nullable\n public <T> T get(Key<T> key) {\n return (T) data.get(key);\n }\n\n /**\n * Returns set of keys stored in container.\n *\n * @return Set of Key objects.\n * @deprecated This method is being considered for removal, if you feel this method is needed\n * please reach out on this Github issue:\n * <a href=\"https://github.com/grpc/grpc-java/issues/1764\">grpc-java/issues/1764</a>.\n */\n @Deprecated\n public Set<Key<?>> keys() {\n return Collections.unmodifiableSet(data.keySet());\n }\n\n Set<Key<?>> keysForTest() {\n return Collections.unmodifiableSet(data.keySet());\n }\n\n /**\n * Create a new builder that is pre-populated with the content from a given container.\n * @deprecated Use {@link Attributes#toBuilder()} on the {@link Attributes} instance instead.\n * This method will be removed in the future.\n */\n @Deprecated\n public static Builder newBuilder(Attributes base) {\n checkNotNull(base, \"base\");\n return new Builder(base);\n }\n\n /**\n * Create a new builder.\n */\n public static Builder newBuilder() {\n return new Builder(EMPTY);\n }\n\n /**\n * Creates a new builder that is pre-populated with the content of this container.\n * @return a new builder.\n */\n public Builder toBuilder() {\n return new Builder(this);\n }\n\n /**\n * Key for an key-value pair. Uses reference equality.\n *\n * @param <T> type of the value in the key-value pair\n */\n @Immutable\n @SuppressWarnings(\"UnusedTypeParameter\")\n public static final class Key<T> {\n private final String debugString;\n\n private Key(String debugString) {\n this.debugString = debugString;\n }\n\n @Override\n public String toString() {\n return debugString;\n }\n\n /**\n * Factory method for creating instances of {@link Key}.\n *\n * @param debugString a string used to describe the key, used for debugging.\n * @param <T> Key type\n * @return Key object\n * @deprecated use {@link #create} instead. This method will be removed in the future.\n */\n @Deprecated\n public static <T> Key<T> of(String debugString) {\n return new Key<>(debugString);\n }\n\n /**\n * Factory method for creating instances of {@link Key}.\n *\n * @param debugString a string used to describe the key, used for debugging.\n * @param <T> Key type\n * @return Key object\n */\n public static <T> Key<T> create(String debugString) {\n return new Key<>(debugString);\n }\n }\n\n @Override\n public String toString() {\n return data.toString();\n }\n\n /**\n * Returns true if the given object is also a {@link Attributes} with an equal attribute values.\n *\n * <p>Note that if a stored values are mutable, it is possible for two objects to be considered\n * equal at one point in time and not equal at another (due to concurrent mutation of attribute\n * values).\n *\n * <p>This method is not implemented efficiently and is meant for testing.\n *\n * @param o an object.\n * @return true if the given object is a {@link Attributes} equal attributes.\n */\n @Override\n public boolean equals(Object o) {\n if (this == o) {\n return true;\n }\n if (o == null || getClass() != o.getClass()) {\n return false;\n }\n Attributes that = (Attributes) o;\n if (data.size() != that.data.size()) {\n return false;\n }\n for (Map.Entry<Key<?>, Object> e : data.entrySet()) {\n if (!that.data.containsKey(e.getKey())) {\n return false;\n }\n if (!Objects.equal(e.getValue(), that.data.get(e.getKey()))) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Returns a hash code for the attributes.\n *\n * <p>Note that if a stored values are mutable, it is possible for two objects to be considered\n * equal at one point in time and not equal at another (due to concurrent mutation of attribute\n * values).\n *\n * @return a hash code for the attributes map.\n */\n @Override\n public int hashCode() {\n int hashCode = 0;\n for (Map.Entry<Key<?>, Object> e : data.entrySet()) {\n hashCode += Objects.hashCode(e.getKey(), e.getValue());\n }\n return hashCode;\n }\n\n /**\n * The helper class to build an Attributes instance.\n */\n public static final class Builder {\n // Exactly one of base and newdata will be set\n private Attributes base;\n private IdentityHashMap<Key<?>, Object> newdata;\n\n private Builder(Attributes base) {\n assert base != null;\n this.base = base;\n }\n\n private IdentityHashMap<Key<?>, Object> data(int size) {\n if (newdata == null) {\n newdata = new IdentityHashMap<>(base.data.size() + size);\n newdata.putAll(base.data);\n base = null;\n }\n assert base == null;\n return newdata;\n }\n\n public <T> Builder set(Key<T> key, T value) {\n data(1).put(key, value);\n return this;\n }\n\n /**\n * Removes the key and associated value from the attributes.\n *\n * @since 1.22.0\n * @param key The key to remove\n * @return this\n */\n public <T> Builder discard(Key<T> key) {\n if (base != null) {\n if (base.data.containsKey(key)) {\n data(0).remove(key);\n }\n } else {\n newdata.remove(key);\n }\n return this;\n }\n\n public Builder setAll(Attributes other) {\n data(other.data.size()).putAll(other.data);\n return this;\n }\n\n /**\n * Build the attributes.\n */\n public Attributes build() {\n if (newdata != null) {\n base = new Attributes(newdata);\n newdata = null;\n }\n return base;\n }\n }\n}\n"}, {"path": "api/src/main/java/io/grpc/BinaryLog.java", "content": "/*\n * Copyright 2018, gRPC Authors All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport java.io.Closeable;\n\n/**\n * A binary log that can be installed on a channel or server. {@link #close} must be called after\n * all the servers and channels associated with the binary log are terminated.\n */\n@ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/4017\")\npublic abstract class BinaryLog implements Closeable {\n\n public abstract <ReqT, RespT> ServerMethodDefinition<?, ?> wrapMethodDefinition(\n ServerMethodDefinition<ReqT, RespT> oMethodDef);\n\n public abstract Channel wrapChannel(Channel channel);\n}\n"}, {"path": "api/src/main/java/io/grpc/BindableService.java", "content": "/*\n * Copyright 2016 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\n/**\n * Provides a way to bind instance of service implementation to server.\n *\n * <p>It is used by service's abstract class generated by compiler (eg.:\n * RouteGuideGrpc.RouteGuideImplBase for RouteGuide service) and lets implementation classes to be\n * bind to server.\n *\n * <pre><code>\n * class RouteGuideService extends RouteGuideGrpc.RouteGuideImplBase {\n * // ...\n * }\n *\n * Server server = ServerBuilder.forPort(1234).addService(new RouteGuideService()).build();\n * </code></pre></p>\n */\npublic interface BindableService {\n /**\n * Creates {@link ServerServiceDefinition} object for current instance of service implementation.\n *\n * @return ServerServiceDefinition object.\n */\n ServerServiceDefinition bindService();\n}\n"}, {"path": "api/src/main/java/io/grpc/CallCredentials.java", "content": "/*\n * Copyright 2016 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport java.util.concurrent.Executor;\n\n/**\n * Carries credential data that will be propagated to the server via request metadata for each RPC.\n *\n * <p>This is used by {@link CallOptions#withCallCredentials} and {@code withCallCredentials()} on\n * the generated stub, for example:\n * <pre>\n * FooGrpc.FooStub stub = FooGrpc.newStub(channel);\n * response = stub.withCallCredentials(creds).bar(request);\n * </pre>\n *\n * <p>The contents and nature of this class (and whether it remains an abstract class) is\n * experimental, in that it can change. However, we are guaranteeing stability for the\n * <em>name</em>. That is, we are guaranteeing stability for code to be returned a reference and\n * pass that reference to gRPC for usage. However, code may not call or implement the {@code\n * CallCredentials} itself if it wishes to only use stable APIs.\n */\npublic abstract class CallCredentials {\n\n /**\n * Pass the credential data to the given {@link CallCredentials.MetadataApplier}, which will\n * propagate it to the request metadata.\n *\n * <p>It is called for each individual RPC, within the {@link Context} of the call, before the\n * stream is about to be created on a transport. Implementations should not block in this\n * method. If metadata is not immediately available, e.g., needs to be fetched from network, the\n * implementation may give the {@code appExecutor} an asynchronous task which will eventually call\n * the {@code applier}. The RPC proceeds only after the {@code applier} is called.\n *\n * @param requestInfo request-related information\n * @param appExecutor The application thread-pool. It is provided to the implementation in case it\n * needs to perform blocking operations.\n * @param applier The outlet of the produced headers. It can be called either before or after this\n * method returns.\n */\n public abstract void applyRequestMetadata(\n RequestInfo requestInfo, Executor appExecutor, CallCredentials.MetadataApplier applier);\n\n /**\n * With this class now being stable this method moves from an abstract one to a normal one with\n * a no-op implementation. This method is marked deprecated to allow extenders time to remove the\n * method before it is removed here.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/1914\")\n @Deprecated\n public void thisUsesUnstableApi() {\n }\n\n /**\n * The outlet of the produced headers. Not thread-safe.\n *\n * <p>Exactly one of its methods must be called to make the RPC proceed.\n */\n public abstract static class MetadataApplier {\n /**\n * Called when headers are successfully generated. They will be merged into the original\n * headers.\n */\n public abstract void apply(Metadata headers);\n\n /**\n * Called when there has been an error when preparing the headers. This will fail the RPC.\n */\n public abstract void fail(Status status);\n }\n\n /**\n * The request-related information passed to {@code CallCredentials.applyRequestMetadata()}.\n */\n public abstract static class RequestInfo {\n /**\n * The method descriptor of this RPC.\n */\n public abstract MethodDescriptor<?, ?> getMethodDescriptor();\n\n /**\n * The call options used to call this RPC.\n */\n public CallOptions getCallOptions() {\n throw new UnsupportedOperationException(\"Not implemented\");\n }\n\n /**\n * The security level on the transport.\n */\n public abstract SecurityLevel getSecurityLevel();\n\n /**\n * Returns the authority string used to authenticate the server for this call.\n */\n public abstract String getAuthority();\n\n /**\n * Returns the transport attributes.\n */\n @Grpc.TransportAttr\n public abstract Attributes getTransportAttrs();\n }\n}\n"}, {"path": "api/src/main/java/io/grpc/CallOptions.java", "content": "/*\n * Copyright 2015 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport static com.google.common.base.Preconditions.checkArgument;\nimport static io.grpc.TimeUtils.convertToNanos;\n\nimport com.google.common.base.MoreObjects;\nimport com.google.common.base.Preconditions;\nimport com.google.errorprone.annotations.CheckReturnValue;\nimport java.time.Duration;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\nimport java.util.concurrent.Executor;\nimport java.util.concurrent.TimeUnit;\nimport javax.annotation.Nullable;\nimport javax.annotation.concurrent.Immutable;\n\n/**\n * The collection of runtime options for a new RPC call.\n *\n * <p>A field that is not set is {@code null}.\n */\n@Immutable\n@CheckReturnValue\npublic final class CallOptions {\n /**\n * A blank {@code CallOptions} that all fields are not set.\n */\n public static final CallOptions DEFAULT;\n\n static {\n Builder b = new Builder();\n b.customOptions = new Object[0][2];\n b.streamTracerFactories = Collections.emptyList();\n DEFAULT = b.build();\n }\n\n @Nullable\n private final Deadline deadline;\n\n @Nullable\n private final Executor executor;\n\n @Nullable\n private final String authority;\n\n @Nullable\n private final CallCredentials credentials;\n\n @Nullable\n private final String compressorName;\n\n private final Object[][] customOptions;\n\n private final List<ClientStreamTracer.Factory> streamTracerFactories;\n\n /**\n * Opposite to fail fast.\n */\n @Nullable\n private final Boolean waitForReady;\n\n @Nullable\n private final Integer maxInboundMessageSize;\n @Nullable\n private final Integer maxOutboundMessageSize;\n @Nullable\n private final Integer onReadyThreshold;\n\n private CallOptions(Builder builder) {\n this.deadline = builder.deadline;\n this.executor = builder.executor;\n this.authority = builder.authority;\n this.credentials = builder.credentials;\n this.compressorName = builder.compressorName;\n this.customOptions = builder.customOptions;\n this.streamTracerFactories = builder.streamTracerFactories;\n this.waitForReady = builder.waitForReady;\n this.maxInboundMessageSize = builder.maxInboundMessageSize;\n this.maxOutboundMessageSize = builder.maxOutboundMessageSize;\n this.onReadyThreshold = builder.onReadyThreshold;\n }\n\n static class Builder {\n Deadline deadline;\n Executor executor;\n String authority;\n CallCredentials credentials;\n String compressorName;\n Object[][] customOptions;\n // Unmodifiable list\n List<ClientStreamTracer.Factory> streamTracerFactories;\n Boolean waitForReady;\n Integer maxInboundMessageSize;\n Integer maxOutboundMessageSize;\n Integer onReadyThreshold;\n\n private CallOptions build() {\n return new CallOptions(this);\n }\n }\n\n /**\n * Override the HTTP/2 authority the channel claims to be connecting to. <em>This is not\n * generally safe.</em> Overriding allows advanced users to re-use a single Channel for multiple\n * services, even if those services are hosted on different domain names. That assumes the\n * server is virtually hosting multiple domains and is guaranteed to continue doing so. It is\n * rare for a service provider to make such a guarantee. <em>At this time, there is no security\n * verification of the overridden value, such as making sure the authority matches the server's\n * TLS certificate.</em>\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/1767\")\n public CallOptions withAuthority(@Nullable String authority) {\n Builder builder = toBuilder(this);\n builder.authority = authority;\n return builder.build();\n }\n\n /**\n * Returns a new {@code CallOptions} with the given call credentials.\n */\n public CallOptions withCallCredentials(@Nullable CallCredentials credentials) {\n Builder builder = toBuilder(this);\n builder.credentials = credentials;\n return builder.build();\n }\n\n /**\n * Sets the compression to use for the call. The compressor must be a valid name known in the\n * {@link CompressorRegistry}. By default, the \"gzip\" compressor will be available.\n *\n * <p>It is only safe to call this if the server supports the compression format chosen. There is\n * no negotiation performed; if the server does not support the compression chosen, the call will\n * fail.\n */\n public CallOptions withCompression(@Nullable String compressorName) {\n Builder builder = toBuilder(this);\n builder.compressorName = compressorName;\n return builder.build();\n }\n\n /**\n * Returns a new {@code CallOptions} with the given absolute deadline.\n *\n * <p>This is mostly used for propagating an existing deadline. {@link #withDeadlineAfter} is the\n * recommended way of setting a new deadline,\n *\n * @param deadline the deadline or {@code null} for unsetting the deadline.\n */\n public CallOptions withDeadline(@Nullable Deadline deadline) {\n Builder builder = toBuilder(this);\n builder.deadline = deadline;\n return builder.build();\n }\n\n /**\n * Returns a new {@code CallOptions} with a deadline that is after the given {@code duration} from\n * now.\n */\n public CallOptions withDeadlineAfter(long duration, TimeUnit unit) {\n return withDeadline(Deadline.after(duration, unit));\n }\n\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/11657\")\n public CallOptions withDeadlineAfter(Duration duration) {\n return withDeadlineAfter(convertToNanos(duration), TimeUnit.NANOSECONDS);\n }\n\n /**\n * Returns the deadline or {@code null} if the deadline is not set.\n */\n @Nullable\n public Deadline getDeadline() {\n return deadline;\n }\n\n /**\n * Enables <a href=\"https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md\">\n * 'wait for ready'</a> for the call. Wait-for-ready queues the RPC until a connection is\n * available. This may dramatically increase the latency of the RPC, but avoids failing\n * \"unnecessarily.\" The default queues the RPC until an attempt to connect has completed, but\n * fails RPCs without sending them if unable to connect.\n */\n public CallOptions withWaitForReady() {\n Builder builder = toBuilder(this);\n builder.waitForReady = Boolean.TRUE;\n return builder.build();\n }\n\n /**\n * Disables 'wait for ready' feature for the call.\n * This method should be rarely used because the default is without 'wait for ready'.\n */\n public CallOptions withoutWaitForReady() {\n Builder builder = toBuilder(this);\n builder.waitForReady = Boolean.FALSE;\n return builder.build();\n }\n\n /**\n * Specifies how many bytes must be queued before the call is\n * considered not ready to send more messages.\n *\n * @param numBytes The number of bytes that must be queued. Must be a\n * positive integer.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/11021\")\n public CallOptions withOnReadyThreshold(int numBytes) {\n checkArgument(numBytes > 0, \"numBytes must be positive: %s\", numBytes);\n Builder builder = toBuilder(this);\n builder.onReadyThreshold = numBytes;\n return builder.build();\n }\n\n /**\n * Resets to the default number of bytes that must be queued before the\n * call will leave the <a href=\"https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md\">\n * 'wait for ready'</a> state.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/11021\")\n public CallOptions clearOnReadyThreshold() {\n Builder builder = toBuilder(this);\n builder.onReadyThreshold = null;\n return builder.build();\n }\n\n /**\n * Returns to the default number of bytes that must be queued before the\n * call will leave the <a href=\"https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md\">\n * 'wait for ready'</a> state.\n *\n * @return null if the default threshold is used.\n */\n @Nullable\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/11021\")\n public Integer getOnReadyThreshold() {\n return onReadyThreshold;\n }\n\n /**\n * Returns the compressor's name.\n */\n @Nullable\n public String getCompressor() {\n return compressorName;\n }\n\n /**\n * Override the HTTP/2 authority the channel claims to be connecting to. <em>This is not\n * generally safe.</em> Overriding allows advanced users to re-use a single Channel for multiple\n * services, even if those services are hosted on different domain names. That assumes the\n * server is virtually hosting multiple domains and is guaranteed to continue doing so. It is\n * rare for a service provider to make such a guarantee. <em>At this time, there is no security\n * verification of the overridden value, such as making sure the authority matches the server's\n * TLS certificate.</em>\n */\n @Nullable\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/1767\")\n public String getAuthority() {\n return authority;\n }\n\n /**\n * Returns the call credentials.\n */\n @Nullable\n public CallCredentials getCredentials() {\n return credentials;\n }\n\n /**\n * Returns a new {@code CallOptions} with {@code executor} to be used instead of the default\n * executor specified with {@link ManagedChannelBuilder#executor}.\n */\n public CallOptions withExecutor(@Nullable Executor executor) {\n Builder builder = toBuilder(this);\n builder.executor = executor;\n return builder.build();\n }\n\n /**\n * Returns a new {@code CallOptions} with a {@code ClientStreamTracerFactory} in addition to\n * the existing factories.\n *\n * <p>This method doesn't replace existing factories, or try to de-duplicate factories.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/2861\")\n public CallOptions withStreamTracerFactory(ClientStreamTracer.Factory factory) {\n ArrayList<ClientStreamTracer.Factory> newList =\n new ArrayList<>(streamTracerFactories.size() + 1);\n newList.addAll(streamTracerFactories);\n newList.add(factory);\n Builder builder = toBuilder(this);\n builder.streamTracerFactories = Collections.unmodifiableList(newList);\n return builder.build();\n }\n\n /**\n * Returns an immutable list of {@code ClientStreamTracerFactory}s.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/2861\")\n public List<ClientStreamTracer.Factory> getStreamTracerFactories() {\n return streamTracerFactories;\n }\n\n /**\n * Key for a key-value pair. Uses reference equality.\n */\n public static final class Key<T> {\n private final String debugString;\n private final T defaultValue;\n\n private Key(String debugString, T defaultValue) {\n this.debugString = debugString;\n this.defaultValue = defaultValue;\n }\n\n /**\n * Returns the user supplied default value for this key.\n */\n public T getDefault() {\n return defaultValue;\n }\n\n @Override\n public String toString() {\n return debugString;\n }\n\n /**\n * Factory method for creating instances of {@link Key}.\n *\n * @param debugString a string used to describe this key, used for debugging.\n * @param defaultValue default value to return when value for key not set\n * @param <T> Key type\n * @return Key object\n * @deprecated Use {@link #create} or {@link #createWithDefault} instead. This method will\n * be removed.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/1869\")\n @Deprecated\n public static <T> Key<T> of(String debugString, T defaultValue) {\n Preconditions.checkNotNull(debugString, \"debugString\");\n return new Key<>(debugString, defaultValue);\n }\n\n /**\n * Factory method for creating instances of {@link Key}. The default value of the\n * key is {@code null}.\n *\n * @param debugString a debug string that describes this key.\n * @param <T> Key type\n * @return Key object\n * @since 1.13.0\n */\n public static <T> Key<T> create(String debugString) {\n Preconditions.checkNotNull(debugString, \"debugString\");\n return new Key<>(debugString, /*defaultValue=*/ null);\n }\n\n /**\n * Factory method for creating instances of {@link Key}.\n *\n * @param debugString a debug string that describes this key.\n * @param defaultValue default value to return when value for key not set\n * @param <T> Key type\n * @return Key object\n * @since 1.13.0\n */\n public static <T> Key<T> createWithDefault(String debugString, T defaultValue) {\n Preconditions.checkNotNull(debugString, \"debugString\");\n return new Key<>(debugString, defaultValue);\n }\n }\n\n /**\n * Sets a custom option. Any existing value for the key is overwritten.\n *\n * @param key The option key\n * @param value The option value.\n * @since 1.13.0\n */\n public <T> CallOptions withOption(Key<T> key, T value) {\n Preconditions.checkNotNull(key, \"key\");\n Preconditions.checkNotNull(value, \"value\");\n\n Builder builder = toBuilder(this);\n int existingIdx = -1;\n for (int i = 0; i < customOptions.length; i++) {\n if (key.equals(customOptions[i][0])) {\n existingIdx = i;\n break;\n }\n }\n\n builder.customOptions = new Object[customOptions.length + (existingIdx == -1 ? 1 : 0)][2];\n System.arraycopy(customOptions, 0, builder.customOptions, 0, customOptions.length);\n\n if (existingIdx == -1) {\n // Add a new option\n builder.customOptions[customOptions.length] = new Object[] {key, value};\n } else {\n // Replace an existing option\n builder.customOptions[existingIdx] = new Object[] {key, value};\n }\n\n return builder.build();\n }\n\n /**\n * Get the value for a custom option or its inherent default.\n * @param key Key identifying option\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/1869\")\n @SuppressWarnings(\"unchecked\")\n public <T> T getOption(Key<T> key) {\n Preconditions.checkNotNull(key, \"key\");\n for (int i = 0; i < customOptions.length; i++) {\n if (key.equals(customOptions[i][0])) {\n return (T) customOptions[i][1];\n }\n }\n return key.defaultValue;\n }\n\n /**\n * Returns the executor override to use for this specific call, or {@code null} if there is no\n * override. The executor is only for servicing this one call, so is not safe to use after\n * {@link ClientCall.Listener#onClose}.\n */\n @Nullable\n public Executor getExecutor() {\n return executor;\n }\n\n /**\n * Returns whether <a href=\"https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md\">\n * 'wait for ready'</a> option is enabled for the call. 'Fail fast' is the default option for gRPC\n * calls and 'wait for ready' is the opposite to it.\n */\n public boolean isWaitForReady() {\n return Boolean.TRUE.equals(waitForReady);\n }\n\n Boolean getWaitForReady() {\n return waitForReady;\n }\n\n /**\n * Sets the maximum allowed message size acceptable from the remote peer. If unset, this will\n * default to the value set on the {@link ManagedChannelBuilder#maxInboundMessageSize(int)}.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/2563\")\n public CallOptions withMaxInboundMessageSize(int maxSize) {\n checkArgument(maxSize >= 0, \"invalid maxsize %s\", maxSize);\n Builder builder = toBuilder(this);\n builder.maxInboundMessageSize = maxSize;\n return builder.build();\n }\n\n /**\n * Sets the maximum allowed message size acceptable sent to the remote peer.\n */\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/2563\")\n public CallOptions withMaxOutboundMessageSize(int maxSize) {\n checkArgument(maxSize >= 0, \"invalid maxsize %s\", maxSize);\n Builder builder = toBuilder(this);\n builder.maxOutboundMessageSize = maxSize;\n return builder.build();\n }\n\n /**\n * Gets the maximum allowed message size acceptable from the remote peer.\n */\n @Nullable\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/2563\")\n public Integer getMaxInboundMessageSize() {\n return maxInboundMessageSize;\n }\n\n /**\n * Gets the maximum allowed message size acceptable to send the remote peer.\n */\n @Nullable\n @ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/2563\")\n public Integer getMaxOutboundMessageSize() {\n return maxOutboundMessageSize;\n }\n\n /**\n * Copy CallOptions.\n */\n private static Builder toBuilder(CallOptions other) {\n Builder builder = new Builder();\n builder.deadline = other.deadline;\n builder.executor = other.executor;\n builder.authority = other.authority;\n builder.credentials = other.credentials;\n builder.compressorName = other.compressorName;\n builder.customOptions = other.customOptions;\n builder.streamTracerFactories = other.streamTracerFactories;\n builder.waitForReady = other.waitForReady;\n builder.maxInboundMessageSize = other.maxInboundMessageSize;\n builder.maxOutboundMessageSize = other.maxOutboundMessageSize;\n builder.onReadyThreshold = other.onReadyThreshold;\n return builder;\n }\n\n @Override\n public String toString() {\n return MoreObjects.toStringHelper(this)\n .add(\"deadline\", deadline)\n .add(\"authority\", authority)\n .add(\"callCredentials\", credentials)\n .add(\"executor\", executor != null ? executor.getClass() : null)\n .add(\"compressorName\", compressorName)\n .add(\"customOptions\", Arrays.deepToString(customOptions))\n .add(\"waitForReady\", isWaitForReady())\n .add(\"maxInboundMessageSize\", maxInboundMessageSize)\n .add(\"maxOutboundMessageSize\", maxOutboundMessageSize)\n .add(\"onReadyThreshold\", onReadyThreshold)\n .add(\"streamTracerFactories\", streamTracerFactories)\n .toString();\n }\n}\n"}, {"path": "api/src/main/java/io/grpc/CallbackMetricInstrument.java", "content": "/*\n * Copyright 2024 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\n/**\n * Tagging interface for MetricInstruments that can be used with batch callbacks.\n */\n@Internal\npublic interface CallbackMetricInstrument extends MetricInstrument {}\n"}, {"path": "api/src/main/java/io/grpc/Channel.java", "content": "/*\n * Copyright 2014 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport javax.annotation.concurrent.ThreadSafe;\n\n/**\n * A virtual connection to a conceptual endpoint, to perform RPCs. A channel is free to have zero or\n * many actual connections to the endpoint based on configuration, load, etc. A channel is also free\n * to determine which actual endpoints to use and may change it every RPC, permitting client-side\n * load balancing. Applications are generally expected to use stubs instead of calling this class\n * directly.\n *\n * <p>Applications can add common cross-cutting behaviors to stubs by decorating Channel\n * implementations using {@link ClientInterceptor}. It is expected that most application\n * code will not use this class directly but rather work with stubs that have been bound to a\n * Channel that was decorated during application initialization.\n */\n@ThreadSafe\npublic abstract class Channel {\n /**\n * Create a {@link ClientCall} to the remote operation specified by the given\n * {@link MethodDescriptor}. The returned {@link ClientCall} does not trigger any remote\n * behavior until {@link ClientCall#start(ClientCall.Listener, Metadata)} is\n * invoked.\n *\n * @param methodDescriptor describes the name and parameter types of the operation to call.\n * @param callOptions runtime options to be applied to this call.\n * @return a {@link ClientCall} bound to the specified method.\n * @since 1.0.0\n */\n public abstract <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(\n MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions);\n\n /**\n * The authority of the destination this channel connects to. Typically this is in the format\n * {@code host:port}.\n *\n * @since 1.0.0\n */\n public abstract String authority();\n}\n"}, {"path": "api/src/main/java/io/grpc/ChannelCredentials.java", "content": "/*\n * Copyright 2020 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\n/**\n * Represents a security configuration to be used for channels. There is no generic mechanism for\n * processing arbitrary {@code ChannelCredentials}; the consumer of the credential (the channel)\n * must support each implementation explicitly and separately. Consumers are not required to support\n * all types or even all possible configurations for types that are partially supported, but they\n * <em>must</em> at least fully support {@link ChoiceChannelCredentials}.\n *\n * <p>A {@code ChannelCredential} provides client identity and authenticates the server. This is\n * different from {@link CallCredentials}, which only provides client identity. They can also\n * influence types of encryption used and similar security configuration.\n *\n * <p>The concrete credential type should not be relevant to most users of the API and may be an\n * implementation decision. Users should generally use the {@code ChannelCredentials} type for\n * variables instead of the concrete type. Freshly-constructed credentials should be returned as\n * {@code ChannelCredentials} instead of a concrete type to encourage this pattern. Concrete types\n * would only be used after {@code instanceof} checks (which must consider\n * {@code ChoiceChannelCredentials}!).\n */\npublic abstract class ChannelCredentials {\n /**\n * Returns the ChannelCredentials stripped of its CallCredentials. In the future,\n * this may strip only some of the CallCredentials, preserving call credentials\n * that are safe from replay attacks (e.g., if the token is bound to the\n * channel's certificate).\n *\n * @since 1.35.0\n */\n public abstract ChannelCredentials withoutBearerTokens();\n}\n"}, {"path": "api/src/main/java/io/grpc/ChannelLogger.java", "content": "/*\n * Copyright 2018 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport javax.annotation.concurrent.ThreadSafe;\n\n/**\n * A Channel-specific logger provided by GRPC library to {@link LoadBalancer} implementations.\n * Information logged here goes to <strong>Channelz</strong>, and to the Java logger of this class\n * as well.\n */\n@ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/5029\")\n@ThreadSafe\npublic abstract class ChannelLogger {\n /**\n * Log levels. See the table below for the mapping from the ChannelLogger levels to Channelz\n * severity level (see {@code ChannelTraceEvent} from <a\n * href=\"https://github.com/grpc/grpc-java/blob/master/services/src/main/proto/grpc/channelz/v1/channelz.proto\">channelz.proto</a>)\n * and Java logger levels. Note that {@code DEBUG} level is not recorded on Channelz.\n * <pre>\n * +---------------------+-------------------+-------------------+\n * | ChannelLogger Level | Channelz Severity | Java Logger Level |\n * +---------------------+-------------------+-------------------+\n * | DEBUG | N/A | FINEST |\n * | INFO | CT_INFO | FINER |\n * | WARNING | CT_WARNING | FINE |\n * | ERROR | CT_ERROR | FINE |\n * +---------------------+-------------------+-------------------+\n * </pre>\n */\n public enum ChannelLogLevel {\n DEBUG,\n INFO,\n WARNING,\n ERROR\n }\n\n /**\n * Logs a message.\n */\n public abstract void log(ChannelLogLevel level, String message);\n\n /**\n * Logs a message, using a message format and a list of arguments used to generate the log\n * message with {@link java.text.MessageFormat}.\n */\n public abstract void log(ChannelLogLevel level, String messageFormat, Object... args);\n}\n"}, {"path": "api/src/main/java/io/grpc/ChoiceChannelCredentials.java", "content": "/*\n * Copyright 2020 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc;\n\nimport static java.util.Collections.unmodifiableList;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\n/**\n * Provides a list of {@link ChannelCredentials}, where any one may be used. The credentials are in\n * preference order.\n */\npublic final class ChoiceChannelCredentials extends ChannelCredentials {\n /**\n * Constructs with the provided {@code creds} as options, with preferred credentials first.\n *\n * @throws IllegalArgumentException if no creds are provided\n */\n public static ChannelCredentials create(ChannelCredentials... creds) {\n if (creds.length == 0) {\n throw new IllegalArgumentException(\"At least one credential is required\");\n }\n for (ChannelCredentials cred : creds) {\n if (cred == null) {\n throw new NullPointerException();\n }\n }\n return new ChoiceChannelCredentials(unmodifiableList(new ArrayList<>(Arrays.asList(creds))));\n }\n\n private final List<ChannelCredentials> creds;\n\n private ChoiceChannelCredentials(List<ChannelCredentials> creds) {\n this.creds = creds;\n }\n\n /** Non-empty list of credentials, in preference order. */\n public List<ChannelCredentials> getCredentialsList() {\n return creds;\n }\n\n @Override\n public ChannelCredentials withoutBearerTokens() {\n List<ChannelCredentials> credsWithoutTokens = new ArrayList<>();\n for (ChannelCredentials cred : creds) {\n credsWithoutTokens.add(cred.withoutBearerTokens());\n }\n return new ChoiceChannelCredentials(unmodifiableList(credsWithoutTokens));\n }\n}\n"}], "context_lines": 1493, "buggy_files": ["api/src/main/java/io/grpc/EquivalentAddressGroup.java", "api/src/main/java/io/grpc/InternalEquivalentAddressGroup.java", "core/src/main/java/io/grpc/internal/InternalSubchannel.java", "xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java"], "test_files": [{"path": "core/src/test/java/io/grpc/internal/InternalSubchannelTest.java", "content": "/*\n * Copyright 2015 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc.internal;\n\nimport static com.google.common.truth.Truth.assertThat;\nimport static io.grpc.ConnectivityState.CONNECTING;\nimport static io.grpc.ConnectivityState.IDLE;\nimport static io.grpc.ConnectivityState.READY;\nimport static io.grpc.ConnectivityState.SHUTDOWN;\nimport static io.grpc.ConnectivityState.TRANSIENT_FAILURE;\nimport static org.junit.Assert.assertEquals;\nimport static org.junit.Assert.assertFalse;\nimport static org.junit.Assert.assertNotNull;\nimport static org.junit.Assert.assertNull;\nimport static org.junit.Assert.assertSame;\nimport static org.junit.Assert.assertThrows;\nimport static org.junit.Assert.assertTrue;\nimport static org.mockito.AdditionalAnswers.delegatesTo;\nimport static org.mockito.ArgumentMatchers.any;\nimport static org.mockito.ArgumentMatchers.argThat;\nimport static org.mockito.ArgumentMatchers.eq;\nimport static org.mockito.ArgumentMatchers.isA;\nimport static org.mockito.ArgumentMatchers.same;\nimport static org.mockito.Mockito.inOrder;\nimport static org.mockito.Mockito.mock;\nimport static org.mockito.Mockito.never;\nimport static org.mockito.Mockito.times;\nimport static org.mockito.Mockito.verify;\nimport static org.mockito.Mockito.verifyNoMoreInteractions;\nimport static org.mockito.Mockito.when;\n\nimport com.google.common.collect.Iterables;\nimport io.grpc.Attributes;\nimport io.grpc.ConnectivityStateInfo;\nimport io.grpc.EquivalentAddressGroup;\nimport io.grpc.InternalChannelz;\nimport io.grpc.InternalEquivalentAddressGroup;\nimport io.grpc.InternalLogId;\nimport io.grpc.InternalWithLogId;\nimport io.grpc.LoadBalancer;\nimport io.grpc.MetricInstrument;\nimport io.grpc.MetricRecorder;\nimport io.grpc.NameResolver;\nimport io.grpc.SecurityLevel;\nimport io.grpc.Status;\nimport io.grpc.SynchronizationContext;\nimport io.grpc.internal.InternalSubchannel.CallTracingTransport;\nimport io.grpc.internal.InternalSubchannel.Index;\nimport io.grpc.internal.InternalSubchannel.TransportLogger;\nimport io.grpc.internal.TestUtils.MockClientTransportInfo;\nimport java.net.SocketAddress;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.LinkedList;\nimport java.util.List;\nimport java.util.concurrent.BlockingQueue;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.atomic.AtomicInteger;\nimport org.junit.After;\nimport org.junit.Before;\nimport org.junit.Rule;\nimport org.junit.Test;\nimport org.junit.runner.RunWith;\nimport org.junit.runners.JUnit4;\nimport org.mockito.InOrder;\nimport org.mockito.Mock;\nimport org.mockito.junit.MockitoJUnit;\nimport org.mockito.junit.MockitoRule;\n\n/**\n * Unit tests for {@link InternalSubchannel}.\n */\n@RunWith(JUnit4.class)\npublic class InternalSubchannelTest {\n @Rule\n public final MockitoRule mocks = MockitoJUnit.rule();\n\n private static final String AUTHORITY = \"fakeauthority\";\n private static final String BACKEND_SERVICE = \"ice-cream-factory-service\";\n private static final String LOCALITY = \"mars-olympus-mons-datacenter\";\n private static final SecurityLevel SECURITY_LEVEL = SecurityLevel.PRIVACY_AND_INTEGRITY;\n private static final String USER_AGENT = \"mosaic\";\n private static final ConnectivityStateInfo UNAVAILABLE_STATE =\n ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE);\n private static final ConnectivityStateInfo RESOURCE_EXHAUSTED_STATE =\n ConnectivityStateInfo.forTransientFailure(Status.RESOURCE_EXHAUSTED);\n private static final Status SHUTDOWN_REASON = Status.UNAVAILABLE.withDescription(\"for test\");\n\n // For scheduled executor\n private final FakeClock fakeClock = new FakeClock();\n // For syncContext\n private final FakeClock fakeExecutor = new FakeClock();\n private final SynchronizationContext syncContext = new SynchronizationContext(\n new Thread.UncaughtExceptionHandler() {\n @Override\n public void uncaughtException(Thread t, Throwable e) {\n throw new AssertionError(e);\n }\n });\n\n private final InternalChannelz channelz = new InternalChannelz();\n\n @Mock private BackoffPolicy mockBackoffPolicy1;\n @Mock private BackoffPolicy mockBackoffPolicy2;\n @Mock private BackoffPolicy mockBackoffPolicy3;\n @Mock private BackoffPolicy.Provider mockBackoffPolicyProvider;\n @Mock private ClientTransportFactory mockTransportFactory;\n\n @Mock private BackoffPolicy mockBackoffPolicy;\n private MetricRecorder mockMetricRecorder = mock(MetricRecorder.class,\n delegatesTo(new MetricRecorderImpl()));\n\n private final LinkedList<String> callbackInvokes = new LinkedList<>();\n private final InternalSubchannel.Callback mockInternalSubchannelCallback =\n new InternalSubchannel.Callback() {\n @Override\n protected void onTerminated(InternalSubchannel is) {\n assertSame(internalSubchannel, is);\n callbackInvokes.add(\"onTerminated\");\n }\n\n @Override\n protected void onStateChange(InternalSubchannel is, ConnectivityStateInfo newState) {\n assertSame(internalSubchannel, is);\n callbackInvokes.add(\"onStateChange:\" + newState);\n }\n\n @Override\n protected void onInUse(InternalSubchannel is) {\n assertSame(internalSubchannel, is);\n callbackInvokes.add(\"onInUse\");\n }\n\n @Override\n protected void onNotInUse(InternalSubchannel is) {\n assertSame(internalSubchannel, is);\n callbackInvokes.add(\"onNotInUse\");\n }\n };\n\n private InternalSubchannel internalSubchannel;\n private BlockingQueue<MockClientTransportInfo> transports;\n\n @Before public void setUp() {\n when(mockBackoffPolicyProvider.get())\n .thenReturn(mockBackoffPolicy1, mockBackoffPolicy2, mockBackoffPolicy3);\n when(mockBackoffPolicy1.nextBackoffNanos()).thenReturn(10L, 100L);\n when(mockBackoffPolicy2.nextBackoffNanos()).thenReturn(10L, 100L);\n when(mockBackoffPolicy3.nextBackoffNanos()).thenReturn(10L, 100L);\n transports = TestUtils.captureTransports(mockTransportFactory);\n }\n\n @After public void noMorePendingTasks() {\n assertEquals(0, fakeClock.numPendingTasks());\n assertEquals(0, fakeExecutor.numPendingTasks());\n }\n\n @Test(expected = IllegalArgumentException.class)\n public void constructor_emptyEagList_throws() {\n createInternalSubchannel(new EquivalentAddressGroup[0]);\n }\n\n @Test(expected = NullPointerException.class)\n public void constructor_eagListWithNull_throws() {\n createInternalSubchannel(new EquivalentAddressGroup[] {null});\n }\n\n @Test public void eagAttribute_propagatesToTransport() {\n SocketAddress addr = new SocketAddress() {};\n Attributes attr = Attributes.newBuilder().set(Attributes.Key.create(\"some-key\"), \"1\").build();\n createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addr), attr));\n\n // First attempt\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory).newClientTransport(\n eq(addr),\n eq(createClientTransportOptions().setEagAttributes(attr)),\n isA(TransportLogger.class));\n }\n\n @Test public void eagAuthorityOverride_propagatesToTransport() {\n SocketAddress addr = new SocketAddress() {};\n String overriddenAuthority = \"authority-override\";\n Attributes attr = Attributes.newBuilder()\n .set(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE, overriddenAuthority).build();\n createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addr), attr));\n\n // First attempt\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory).newClientTransport(\n eq(addr),\n eq(createClientTransportOptions().setAuthority(overriddenAuthority).setEagAttributes(attr)),\n isA(TransportLogger.class));\n }\n\n @Test public void singleAddressReconnect() {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n assertEquals(IDLE, internalSubchannel.getState());\n\n // Invocation counters\n int transportsCreated = 0;\n int backoff1Consulted = 0;\n int backoff2Consulted = 0;\n int backoffReset = 0;\n\n // First attempt\n assertEquals(IDLE, internalSubchannel.getState());\n assertNoCallbackInvoke();\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory, times(++transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // Fail this one. Because there is only one address to try, enter TRANSIENT_FAILURE.\n assertNoCallbackInvoke();\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n // Backoff reset and using first back-off value interval\n verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicyProvider, times(++backoffReset)).get();\n\n // Second attempt\n // Transport creation doesn't happen until time is due\n fakeClock.forwardNanos(9);\n assertNull(internalSubchannel.obtainActiveTransport());\n verify(mockTransportFactory, times(transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n\n assertNoCallbackInvoke();\n fakeClock.forwardNanos(1);\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory, times(++transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n // Fail this one too\n assertNoCallbackInvoke();\n // Here we use a different status from the first failure, and verify that it's passed to\n // the callback.\n transports.poll().listener.transportShutdown(Status.RESOURCE_EXHAUSTED,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:\" + RESOURCE_EXHAUSTED_STATE);\n // Second back-off interval\n verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicyProvider, times(backoffReset)).get();\n\n // Third attempt\n // Transport creation doesn't happen until time is due\n fakeClock.forwardNanos(99);\n assertNull(internalSubchannel.obtainActiveTransport());\n verify(mockTransportFactory, times(transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n assertNoCallbackInvoke();\n fakeClock.forwardNanos(1);\n assertEquals(CONNECTING, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertNull(internalSubchannel.obtainActiveTransport());\n verify(mockTransportFactory, times(++transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n // Let this one succeed, will enter READY state.\n assertNoCallbackInvoke();\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n assertEquals(READY, internalSubchannel.getState());\n assertSame(\n transports.peek().transport,\n ((CallTracingTransport) internalSubchannel.obtainActiveTransport()).delegate());\n\n // Close the READY transport, will enter IDLE state.\n assertNoCallbackInvoke();\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(IDLE, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n\n // Back-off is reset, and the next attempt will happen immediately\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(CONNECTING, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockBackoffPolicyProvider, times(backoffReset)).get();\n verify(mockTransportFactory, times(++transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // Final checks for consultations on back-off policies\n verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffNanos();\n }\n\n @Test public void twoAddressesReconnectDisabled() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n createInternalSubchannel(true,\n new EquivalentAddressGroup(Arrays.asList(addr1, addr2)));\n assertEquals(IDLE, internalSubchannel.getState());\n\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory).newClientTransport(eq(addr1), any(), any());\n // Let this one fail without success\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n // Still in CONNECTING\n assertNull(internalSubchannel.obtainActiveTransport());\n assertNoCallbackInvoke();\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Second attempt will start immediately. Still no back-off policy.\n verify(mockBackoffPolicyProvider, times(0)).get();\n verify(mockTransportFactory, times(1))\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertNull(internalSubchannel.obtainActiveTransport());\n // Fail this one too\n assertNoCallbackInvoke();\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n // All addresses have failed, but we aren't controlling retries.\n assertEquals(IDLE, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n // Backoff reset and first back-off interval begins\n verify(mockBackoffPolicy1, never()).nextBackoffNanos();\n verify(mockBackoffPolicyProvider, never()).get();\n assertTrue(\"Nothing should have been scheduled\", fakeClock.getPendingTasks().isEmpty());\n\n // Should follow orders and create an active transport.\n internalSubchannel.obtainActiveTransport();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Shouldn't have anything scheduled, so shouldn't do anything\n assertTrue(\"Nothing should have been scheduled 2\", fakeClock.getPendingTasks().isEmpty());\n }\n\n @Test public void twoAddressesReconnect() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n createInternalSubchannel(false,\n new EquivalentAddressGroup(Arrays.asList(addr1, addr2)));\n assertEquals(IDLE, internalSubchannel.getState());\n // Invocation counters\n int transportsAddr1 = 0;\n int transportsAddr2 = 0;\n int backoff1Consulted = 0;\n int backoff2Consulted = 0;\n int backoff3Consulted = 0;\n int backoffReset = 0;\n\n // First attempt\n assertNoCallbackInvoke();\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory, times(++transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // Let this one fail without success\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n // Still in CONNECTING\n assertNull(internalSubchannel.obtainActiveTransport());\n assertNoCallbackInvoke();\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Second attempt will start immediately. Still no back-off policy.\n verify(mockBackoffPolicyProvider, times(backoffReset)).get();\n verify(mockTransportFactory, times(++transportsAddr2))\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertNull(internalSubchannel.obtainActiveTransport());\n // Fail this one too\n assertNoCallbackInvoke();\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n // All addresses have failed. Delayed transport will be in back-off interval.\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n // Backoff reset and first back-off interval begins\n verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicyProvider, times(++backoffReset)).get();\n\n // No reconnect during TRANSIENT_FAILURE even when requested.\n assertNull(internalSubchannel.obtainActiveTransport());\n assertNoCallbackInvoke();\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n\n // Third attempt is the first address, thus controlled by the first back-off interval.\n fakeClock.forwardNanos(9);\n verify(mockTransportFactory, times(transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n assertNoCallbackInvoke();\n fakeClock.forwardNanos(1);\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory, times(++transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n // Fail this one too\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Forth attempt will start immediately. Keep back-off policy.\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockBackoffPolicyProvider, times(backoffReset)).get();\n verify(mockTransportFactory, times(++transportsAddr2))\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n // Fail this one too\n assertNoCallbackInvoke();\n transports.poll().listener.transportShutdown(Status.RESOURCE_EXHAUSTED,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n // All addresses have failed again. Delayed transport will be in back-off interval.\n assertExactCallbackInvokes(\"onStateChange:\" + RESOURCE_EXHAUSTED_STATE);\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n // Second back-off interval begins\n verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicyProvider, times(backoffReset)).get();\n\n // Fifth attempt for the first address, thus controlled by the second back-off interval.\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n fakeClock.forwardNanos(99);\n verify(mockTransportFactory, times(transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n assertNoCallbackInvoke();\n fakeClock.forwardNanos(1);\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory, times(++transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n // Let it through\n assertNoCallbackInvoke();\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n assertEquals(READY, internalSubchannel.getState());\n\n assertSame(\n transports.peek().transport,\n ((CallTracingTransport) internalSubchannel.obtainActiveTransport()).delegate());\n // Then close it.\n assertNoCallbackInvoke();\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n assertEquals(IDLE, internalSubchannel.getState());\n\n // First attempt after a successful connection. Old back-off policy should be ignored, but there\n // is not yet a need for a new one. Start from the first address.\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(CONNECTING, internalSubchannel.getState());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockBackoffPolicyProvider, times(backoffReset)).get();\n verify(mockTransportFactory, times(++transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n // Fail the transport\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Second attempt will start immediately. Still no new back-off policy.\n verify(mockBackoffPolicyProvider, times(backoffReset)).get();\n verify(mockTransportFactory, times(++transportsAddr2))\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n // Fail this one too\n assertEquals(CONNECTING, internalSubchannel.getState());\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n // All addresses have failed. Enter TRANSIENT_FAILURE. Back-off in effect.\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n // Back-off reset and first back-off interval begins\n verify(mockBackoffPolicy2, times(++backoff2Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicyProvider, times(++backoffReset)).get();\n\n // Third attempt is the first address, thus controlled by the first back-off interval.\n fakeClock.forwardNanos(9);\n verify(mockTransportFactory, times(transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n assertNoCallbackInvoke();\n fakeClock.forwardNanos(1);\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory, times(++transportsAddr1))\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // Final checks on invocations on back-off policies\n verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffNanos();\n verify(mockBackoffPolicy3, times(backoff3Consulted)).nextBackoffNanos();\n }\n\n @Test\n public void updateAddresses_emptyEagList_throws() {\n SocketAddress addr = new FakeSocketAddress();\n createInternalSubchannel(addr);\n List<EquivalentAddressGroup> newAddressGroups = Collections.emptyList();\n assertThrows(IllegalArgumentException.class,\n () -> internalSubchannel.updateAddresses(newAddressGroups));\n }\n\n @Test\n public void updateAddresses_eagListWithNull_throws() {\n SocketAddress addr = new FakeSocketAddress();\n createInternalSubchannel(addr);\n List<EquivalentAddressGroup> eags = Arrays.asList((EquivalentAddressGroup) null);\n assertThrows(NullPointerException.class, () -> internalSubchannel.updateAddresses(eags));\n }\n\n @Test public void updateAddresses_intersecting_ready() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n SocketAddress addr3 = mock(SocketAddress.class);\n createInternalSubchannel(addr1, addr2);\n assertEquals(IDLE, internalSubchannel.getState());\n\n // First address fails\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Second address connects\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n assertEquals(READY, internalSubchannel.getState());\n\n // Update addresses\n internalSubchannel.updateAddresses(\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));\n assertNoCallbackInvoke();\n assertEquals(READY, internalSubchannel.getState());\n verify(transports.peek().transport, never()).shutdown(any(Status.class));\n verify(transports.peek().transport, never()).shutdownNow(any(Status.class));\n\n // And new addresses chosen when re-connecting\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(0, fakeClock.numPendingTasks());\n verify(mockTransportFactory, times(2))\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr3),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verifyNoMoreInteractions(mockTransportFactory);\n\n fakeClock.forwardNanos(10); // Drain retry, but don't care about result\n }\n\n @Test public void updateAddresses_intersecting_connecting() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n SocketAddress addr3 = mock(SocketAddress.class);\n createInternalSubchannel(addr1, addr2);\n assertEquals(IDLE, internalSubchannel.getState());\n\n // First address fails\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Second address connecting\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertNoCallbackInvoke();\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Update addresses\n internalSubchannel.updateAddresses(\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));\n assertNoCallbackInvoke();\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(transports.peek().transport, never()).shutdown(any(Status.class));\n verify(transports.peek().transport, never()).shutdownNow(any(Status.class));\n\n // And new addresses chosen when re-connecting\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(0, fakeClock.numPendingTasks());\n verify(mockTransportFactory, times(2))\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr3),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verifyNoMoreInteractions(mockTransportFactory);\n\n fakeClock.forwardNanos(10); // Drain retry, but don't care about result\n }\n\n @Test public void updateAddresses_disjoint_idle() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n\n createInternalSubchannel(addr1);\n internalSubchannel.updateAddresses(Arrays.asList(new EquivalentAddressGroup(addr2)));\n\n // Nothing happened on address update\n verify(mockTransportFactory, never())\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n verify(mockTransportFactory, never())\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n verifyNoMoreInteractions(mockTransportFactory);\n assertNoCallbackInvoke();\n assertEquals(IDLE, internalSubchannel.getState());\n\n // But new address chosen when connecting\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // And no other addresses attempted\n assertEquals(0, fakeClock.numPendingTasks());\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());\n verifyNoMoreInteractions(mockTransportFactory);\n\n fakeClock.forwardNanos(10); // Drain retry, but don't care about result\n }\n\n @Test public void updateAddresses_disjoint_ready() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n SocketAddress addr3 = mock(SocketAddress.class);\n SocketAddress addr4 = mock(SocketAddress.class);\n createInternalSubchannel(addr1, addr2);\n assertEquals(IDLE, internalSubchannel.getState());\n\n // First address fails\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Second address connects\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n assertEquals(READY, internalSubchannel.getState());\n\n // Update addresses\n internalSubchannel.updateAddresses(\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr3, addr4))));\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n assertEquals(IDLE, internalSubchannel.getState());\n verify(transports.peek().transport, never()).shutdown(any(Status.class));\n fakeClock.forwardNanos(\n TimeUnit.SECONDS.toNanos(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS));\n verify(transports.peek().transport).shutdown(any(Status.class));\n\n // And new addresses chosen when re-connecting\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertNoCallbackInvoke();\n assertEquals(IDLE, internalSubchannel.getState());\n\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(0, fakeClock.numPendingTasks());\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr3),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr4),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verifyNoMoreInteractions(mockTransportFactory);\n\n fakeClock.forwardNanos(10); // Drain retry, but don't care about result\n }\n\n @Test public void updateAddresses_disjoint_connecting() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n SocketAddress addr3 = mock(SocketAddress.class);\n SocketAddress addr4 = mock(SocketAddress.class);\n createInternalSubchannel(addr1, addr2);\n assertEquals(IDLE, internalSubchannel.getState());\n\n // First address fails\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Second address connecting\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertNoCallbackInvoke();\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // Update addresses\n internalSubchannel.updateAddresses(\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr3, addr4))));\n assertNoCallbackInvoke();\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n // And new addresses chosen immediately\n verify(transports.poll().transport).shutdown(any(Status.class));\n assertNoCallbackInvoke();\n assertEquals(CONNECTING, internalSubchannel.getState());\n\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(0, fakeClock.numPendingTasks());\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr3),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr4),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n verifyNoMoreInteractions(mockTransportFactory);\n\n fakeClock.forwardNanos(10); // Drain retry, but don't care about result\n }\n\n @Test public void updateAddresses_disjoint_readyTwice() {\n SocketAddress addr1 = mock(SocketAddress.class);\n createInternalSubchannel(addr1);\n assertEquals(IDLE, internalSubchannel.getState());\n\n // Address connects\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr1),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n assertEquals(READY, internalSubchannel.getState());\n\n // Update addresses\n SocketAddress addr2 = mock(SocketAddress.class);\n internalSubchannel.updateAddresses(\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr2))));\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n assertEquals(IDLE, internalSubchannel.getState());\n ConnectionClientTransport firstTransport = transports.poll().transport;\n verify(firstTransport, never()).shutdown(any(Status.class));\n\n // Address connects\n assertNull(internalSubchannel.obtainActiveTransport());\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr2),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n assertEquals(READY, internalSubchannel.getState());\n\n // Update addresses\n SocketAddress addr3 = mock(SocketAddress.class);\n internalSubchannel.updateAddresses(\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr3))));\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n assertEquals(IDLE, internalSubchannel.getState());\n // Earlier transport is shutdown eagerly\n verify(firstTransport).shutdown(any(Status.class));\n ConnectionClientTransport secondTransport = transports.peek().transport;\n verify(secondTransport, never()).shutdown(any(Status.class));\n\n internalSubchannel.shutdown(SHUTDOWN_REASON);\n verify(secondTransport).shutdown(any(Status.class));\n }\n\n @Test\n public void connectIsLazy() {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n // Invocation counters\n int transportsCreated = 0;\n\n // Won't connect until requested\n verify(mockTransportFactory, times(transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // First attempt\n internalSubchannel.obtainActiveTransport();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory, times(++transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // Fail this one\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n\n // Will always reconnect after back-off\n fakeClock.forwardNanos(10);\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory, times(++transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // Make this one proceed\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n // Then go-away\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n\n // No scheduled tasks that would ever try to reconnect ...\n assertEquals(0, fakeClock.numPendingTasks());\n assertEquals(0, fakeExecutor.numPendingTasks());\n\n // ... until it's requested.\n internalSubchannel.obtainActiveTransport();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory, times(++transportsCreated))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n }\n\n @Test\n public void shutdownWhenReady() throws Exception {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n internalSubchannel.obtainActiveTransport();\n MockClientTransportInfo transportInfo = transports.poll();\n transportInfo.listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\", \"onStateChange:READY\");\n\n internalSubchannel.shutdown(SHUTDOWN_REASON);\n verify(transportInfo.transport).shutdown(same(SHUTDOWN_REASON));\n assertExactCallbackInvokes(\"onStateChange:SHUTDOWN\");\n transportInfo.listener.transportShutdown(SHUTDOWN_REASON,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n\n transportInfo.listener.transportTerminated();\n assertExactCallbackInvokes(\"onTerminated\");\n verify(transportInfo.transport, never()).shutdownNow(any(Status.class));\n }\n\n @Test\n public void shutdownBeforeTransportCreated() throws Exception {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n // First transport is created immediately\n internalSubchannel.obtainActiveTransport();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n\n // Fail this one\n MockClientTransportInfo transportInfo = transports.poll();\n transportInfo.listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n transportInfo.listener.transportTerminated();\n\n // Entering TRANSIENT_FAILURE, waiting for back-off\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n\n // Save the reconnectTask before shutting down\n FakeClock.ScheduledTask reconnectTask = null;\n for (FakeClock.ScheduledTask task : fakeClock.getPendingTasks()) {\n if (task.command.toString().contains(\"EndOfCurrentBackoff\")) {\n assertNull(\"There shouldn't be more than one reconnectTask\", reconnectTask);\n assertFalse(task.isDone());\n reconnectTask = task;\n }\n }\n assertNotNull(\"There should be at least one reconnectTask\", reconnectTask);\n\n // Shut down InternalSubchannel before the transport is created.\n internalSubchannel.shutdown(SHUTDOWN_REASON);\n assertTrue(reconnectTask.isCancelled());\n // InternalSubchannel terminated promptly.\n assertExactCallbackInvokes(\"onStateChange:SHUTDOWN\", \"onTerminated\");\n\n // Simulate a race between reconnectTask cancellation and execution -- the task runs anyway.\n // This should not lead to the creation of a new transport.\n reconnectTask.command.run();\n\n // Further call to obtainActiveTransport() is no-op.\n assertNull(internalSubchannel.obtainActiveTransport());\n assertEquals(SHUTDOWN, internalSubchannel.getState());\n assertNoCallbackInvoke();\n\n // No more transports will be created.\n fakeClock.forwardNanos(10000);\n assertEquals(SHUTDOWN, internalSubchannel.getState());\n verifyNoMoreInteractions(mockTransportFactory);\n assertEquals(0, transports.size());\n assertNoCallbackInvoke();\n }\n\n @Test\n public void shutdownBeforeTransportReady() throws Exception {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n internalSubchannel.obtainActiveTransport();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n MockClientTransportInfo transportInfo = transports.poll();\n\n // Shutdown the InternalSubchannel before the pending transport is ready\n assertNull(internalSubchannel.obtainActiveTransport());\n internalSubchannel.shutdown(SHUTDOWN_REASON);\n assertExactCallbackInvokes(\"onStateChange:SHUTDOWN\");\n\n // The transport should've been shut down even though it's not the active transport yet.\n verify(transportInfo.transport).shutdown(same(SHUTDOWN_REASON));\n transportInfo.listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertNoCallbackInvoke();\n transportInfo.listener.transportTerminated();\n assertExactCallbackInvokes(\"onTerminated\");\n assertEquals(SHUTDOWN, internalSubchannel.getState());\n }\n\n @Test\n public void shutdownNow() throws Exception {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n internalSubchannel.obtainActiveTransport();\n MockClientTransportInfo t1 = transports.poll();\n t1.listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\", \"onStateChange:READY\");\n t1.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n\n internalSubchannel.obtainActiveTransport();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n MockClientTransportInfo t2 = transports.poll();\n\n Status status = Status.UNAVAILABLE.withDescription(\"Requested\");\n internalSubchannel.shutdownNow(status);\n\n verify(t1.transport).shutdownNow(same(status));\n verify(t2.transport).shutdownNow(same(status));\n assertExactCallbackInvokes(\"onStateChange:SHUTDOWN\");\n }\n\n @Test\n public void obtainTransportAfterShutdown() throws Exception {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n internalSubchannel.shutdown(SHUTDOWN_REASON);\n assertExactCallbackInvokes(\"onStateChange:SHUTDOWN\", \"onTerminated\");\n assertEquals(SHUTDOWN, internalSubchannel.getState());\n assertNull(internalSubchannel.obtainActiveTransport());\n verify(mockTransportFactory, times(0))\n .newClientTransport(\n addr,\n createClientTransportOptions(),\n internalSubchannel.getChannelLogger());\n assertNoCallbackInvoke();\n assertEquals(SHUTDOWN, internalSubchannel.getState());\n }\n\n @Test\n public void logId() {\n createInternalSubchannel(mock(SocketAddress.class));\n\n assertNotNull(internalSubchannel.getLogId());\n }\n\n @Test\n public void inUseState() {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n internalSubchannel.obtainActiveTransport();\n MockClientTransportInfo t0 = transports.poll();\n t0.listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\", \"onStateChange:READY\");\n t0.listener.transportInUse(true);\n assertExactCallbackInvokes(\"onInUse\");\n\n t0.listener.transportInUse(false);\n assertExactCallbackInvokes(\"onNotInUse\");\n\n t0.listener.transportInUse(true);\n assertExactCallbackInvokes(\"onInUse\");\n t0.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n\n assertNull(internalSubchannel.obtainActiveTransport());\n MockClientTransportInfo t1 = transports.poll();\n t1.listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\", \"onStateChange:READY\");\n t1.listener.transportInUse(true);\n // InternalSubchannel is already in-use, thus doesn't call the callback\n assertNoCallbackInvoke();\n\n t1.listener.transportInUse(false);\n // t0 is still in-use\n assertNoCallbackInvoke();\n\n t0.listener.transportInUse(false);\n assertExactCallbackInvokes(\"onNotInUse\");\n }\n\n @Test\n public void transportTerminateWithoutExitingInUse() {\n // An imperfect transport that terminates without going out of in-use. InternalSubchannel will\n // clear the in-use bit for it.\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n internalSubchannel.obtainActiveTransport();\n MockClientTransportInfo t0 = transports.poll();\n t0.listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\", \"onStateChange:READY\");\n t0.listener.transportInUse(true);\n assertExactCallbackInvokes(\"onInUse\");\n\n t0.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:IDLE\");\n t0.listener.transportTerminated();\n assertExactCallbackInvokes(\"onNotInUse\");\n }\n\n @Test\n public void transportStartReturnsRunnable() {\n SocketAddress addr1 = mock(SocketAddress.class);\n SocketAddress addr2 = mock(SocketAddress.class);\n createInternalSubchannel(addr1, addr2);\n final AtomicInteger runnableInvokes = new AtomicInteger(0);\n Runnable startRunnable = new Runnable() {\n @Override\n public void run() {\n runnableInvokes.incrementAndGet();\n }\n };\n transports = TestUtils.captureTransports(mockTransportFactory, startRunnable);\n\n assertEquals(0, runnableInvokes.get());\n internalSubchannel.obtainActiveTransport();\n assertEquals(1, runnableInvokes.get());\n internalSubchannel.obtainActiveTransport();\n assertEquals(1, runnableInvokes.get());\n\n MockClientTransportInfo t0 = transports.poll();\n t0.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertEquals(2, runnableInvokes.get());\n\n // 2nd address: reconnect immediatly\n MockClientTransportInfo t1 = transports.poll();\n t1.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n\n // Addresses exhausted, waiting for back-off.\n assertEquals(2, runnableInvokes.get());\n // Run out the back-off period\n fakeClock.forwardNanos(10);\n assertEquals(3, runnableInvokes.get());\n\n // This test doesn't care about scheduled InternalSubchannel callbacks. Clear it up so that\n // noMorePendingTasks() won't fail.\n fakeExecutor.runDueTasks();\n assertEquals(3, runnableInvokes.get());\n }\n\n @Test\n public void resetConnectBackoff() throws Exception {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n\n // Move into TRANSIENT_FAILURE to schedule reconnect\n internalSubchannel.obtainActiveTransport();\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n verify(mockTransportFactory)\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n\n // Save the reconnectTask\n FakeClock.ScheduledTask reconnectTask = null;\n for (FakeClock.ScheduledTask task : fakeClock.getPendingTasks()) {\n if (task.command.toString().contains(\"EndOfCurrentBackoff\")) {\n assertNull(\"There shouldn't be more than one reconnectTask\", reconnectTask);\n assertFalse(task.isDone());\n reconnectTask = task;\n }\n }\n assertNotNull(\"There should be at least one reconnectTask\", reconnectTask);\n\n internalSubchannel.resetConnectBackoff();\n\n verify(mockTransportFactory, times(2))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertTrue(reconnectTask.isCancelled());\n\n // Simulate a race between cancel and the task scheduler. Should be a no-op.\n reconnectTask.command.run();\n assertNoCallbackInvoke();\n verify(mockTransportFactory, times(2))\n .newClientTransport(\n eq(addr),\n eq(createClientTransportOptions()),\n isA(TransportLogger.class));\n verify(mockBackoffPolicyProvider, times(1)).get();\n\n // Fail the reconnect attempt to verify that a fresh reconnect policy is generated after\n // invoking resetConnectBackoff()\n transports.poll().listener.transportShutdown(Status.UNAVAILABLE,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n assertExactCallbackInvokes(\"onStateChange:\" + UNAVAILABLE_STATE);\n verify(mockBackoffPolicyProvider, times(2)).get();\n fakeClock.forwardNanos(10);\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n }\n\n @Test\n public void resetConnectBackoff_noopOnIdleTransport() throws Exception {\n SocketAddress addr = mock(SocketAddress.class);\n createInternalSubchannel(addr);\n assertEquals(IDLE, internalSubchannel.getState());\n\n internalSubchannel.resetConnectBackoff();\n\n assertNoCallbackInvoke();\n }\n\n @Test\n public void channelzMembership() throws Exception {\n SocketAddress addr1 = mock(SocketAddress.class);\n createInternalSubchannel(addr1);\n internalSubchannel.obtainActiveTransport();\n\n MockClientTransportInfo t0 = transports.poll();\n t0.listener.transportReady();\n assertTrue(channelz.containsClientSocket(t0.transport.getLogId()));\n t0.listener.transportShutdown(Status.RESOURCE_EXHAUSTED,\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n t0.listener.transportTerminated();\n assertFalse(channelz.containsClientSocket(t0.transport.getLogId()));\n }\n\n @Test\n public void channelzStatContainsTransport() throws Exception {\n SocketAddress addr = new SocketAddress() {};\n assertThat(transports).isEmpty();\n createInternalSubchannel(addr);\n internalSubchannel.obtainActiveTransport();\n\n InternalWithLogId registeredTransport\n = Iterables.getOnlyElement(internalSubchannel.getStats().get().sockets);\n MockClientTransportInfo actualTransport = Iterables.getOnlyElement(transports);\n assertEquals(actualTransport.transport.getLogId(), registeredTransport.getLogId());\n }\n\n @Test public void index_looping() {\n Attributes.Key<String> key = Attributes.Key.create(\"some-key\");\n Attributes attr1 = Attributes.newBuilder().set(key, \"1\").build();\n Attributes attr2 = Attributes.newBuilder().set(key, \"2\").build();\n Attributes attr3 = Attributes.newBuilder().set(key, \"3\").build();\n SocketAddress addr1 = new FakeSocketAddress();\n SocketAddress addr2 = new FakeSocketAddress();\n SocketAddress addr3 = new FakeSocketAddress();\n SocketAddress addr4 = new FakeSocketAddress();\n SocketAddress addr5 = new FakeSocketAddress();\n Index index = new Index(Arrays.asList(\n new EquivalentAddressGroup(Arrays.asList(addr1, addr2), attr1),\n new EquivalentAddressGroup(Arrays.asList(addr3), attr2),\n new EquivalentAddressGroup(Arrays.asList(addr4, addr5), attr3)));\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);\n assertThat(index.isAtBeginning()).isTrue();\n assertThat(index.isValid()).isTrue();\n\n index.increment();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);\n assertThat(index.isAtBeginning()).isFalse();\n assertThat(index.isValid()).isTrue();\n\n index.increment();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr2);\n assertThat(index.isAtBeginning()).isFalse();\n assertThat(index.isValid()).isTrue();\n\n index.increment();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);\n assertThat(index.isAtBeginning()).isFalse();\n assertThat(index.isValid()).isTrue();\n\n index.increment();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);\n assertThat(index.isAtBeginning()).isFalse();\n assertThat(index.isValid()).isTrue();\n\n index.increment();\n assertThat(index.isAtBeginning()).isFalse();\n assertThat(index.isValid()).isFalse();\n\n index.reset();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);\n assertThat(index.isAtBeginning()).isTrue();\n assertThat(index.isValid()).isTrue();\n\n // We want to make sure both groupIndex and addressIndex are reset\n index.increment();\n index.increment();\n index.increment();\n index.increment();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);\n index.reset();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);\n assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);\n }\n\n @Test public void index_updateGroups_resets() {\n SocketAddress addr1 = new FakeSocketAddress();\n SocketAddress addr2 = new FakeSocketAddress();\n SocketAddress addr3 = new FakeSocketAddress();\n Index index = new Index(Arrays.asList(\n new EquivalentAddressGroup(Arrays.asList(addr1)),\n new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));\n index.increment();\n index.increment();\n // We want to make sure both groupIndex and addressIndex are reset\n index.updateGroups(Arrays.asList(\n new EquivalentAddressGroup(Arrays.asList(addr1)),\n new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);\n }\n\n @Test public void index_seekTo() {\n SocketAddress addr1 = new FakeSocketAddress();\n SocketAddress addr2 = new FakeSocketAddress();\n SocketAddress addr3 = new FakeSocketAddress();\n Index index = new Index(Arrays.asList(\n new EquivalentAddressGroup(Arrays.asList(addr1, addr2)),\n new EquivalentAddressGroup(Arrays.asList(addr3))));\n assertThat(index.seekTo(addr3)).isTrue();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);\n assertThat(index.seekTo(addr1)).isTrue();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);\n assertThat(index.seekTo(addr2)).isTrue();\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);\n index.seekTo(new FakeSocketAddress());\n // Failed seekTo doesn't change the index\n assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);\n }\n\n @Test\n public void connectedAddressAttributes_ready() {\n SocketAddress addr = new SocketAddress() {};\n Attributes attr = Attributes.newBuilder().set(Attributes.Key.create(\"some-key\"), \"1\").build();\n createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addr), attr));\n\n assertEquals(IDLE, internalSubchannel.getState());\n assertNoCallbackInvoke();\n assertNull(internalSubchannel.obtainActiveTransport());\n assertNull(internalSubchannel.getConnectedAddressAttributes());\n\n assertExactCallbackInvokes(\"onStateChange:CONNECTING\");\n assertEquals(CONNECTING, internalSubchannel.getState());\n verify(mockTransportFactory).newClientTransport(\n eq(addr),\n eq(createClientTransportOptions().setEagAttributes(attr)),\n isA(TransportLogger.class));\n assertNull(internalSubchannel.getConnectedAddressAttributes());\n\n internalSubchannel.obtainActiveTransport();\n transports.peek().listener.transportReady();\n assertExactCallbackInvokes(\"onStateChange:READY\");\n assertEquals(READY, internalSubchannel.getState());\n assertEquals(attr, internalSubchannel.getConnectedAddressAttributes());\n }\n\n /** Create ClientTransportOptions. Should not be reused if it may be mutated. */\n private ClientTransportFactory.ClientTransportOptions createClientTransportOptions() {\n return new ClientTransportFactory.ClientTransportOptions()\n .setAuthority(AUTHORITY)\n .setUserAgent(USER_AGENT);\n }\n\n private void createInternalSubchannel(SocketAddress ... addrs) {\n createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addrs)));\n }\n\n private void createInternalSubchannel(EquivalentAddressGroup ... addrs) {\n createInternalSubchannel(false, addrs);\n }\n\n private void createInternalSubchannel(boolean reconnectDisabled,\n EquivalentAddressGroup ... addrs) {\n List<EquivalentAddressGroup> addressGroups = Arrays.asList(addrs);\n InternalLogId logId = InternalLogId.allocate(\"Subchannel\", /*details=*/ AUTHORITY);\n ChannelTracer subchannelTracer = new ChannelTracer(logId, 10,\n fakeClock.getTimeProvider().currentTimeNanos(), \"Subchannel\");\n LoadBalancer.CreateSubchannelArgs.Builder argBuilder =\n LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(addressGroups);\n if (reconnectDisabled) {\n argBuilder.addOption(LoadBalancer.DISABLE_SUBCHANNEL_RECONNECT_KEY, reconnectDisabled);\n }\n LoadBalancer.CreateSubchannelArgs createSubchannelArgs = argBuilder.build();\n internalSubchannel = new InternalSubchannel(\n createSubchannelArgs,\n AUTHORITY, USER_AGENT,\n mockBackoffPolicyProvider, mockTransportFactory, fakeClock.getScheduledExecutorService(),\n fakeClock.getStopwatchSupplier(), syncContext, mockInternalSubchannelCallback,\n channelz, CallTracer.getDefaultFactory().create(),\n subchannelTracer,\n logId,\n new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()),\n Collections.emptyList(),\n \"\",\n new MetricRecorder() {\n }\n );\n }\n\n @Test\n public void subchannelStateChanges_triggersAttemptFailedMetric() {\n // 1. Setup: Standard subchannel initialization\n when(mockBackoffPolicyProvider.get()).thenReturn(mockBackoffPolicy);\n SocketAddress addr = mock(SocketAddress.class);\n Attributes eagAttributes = Attributes.newBuilder()\n .set(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE, BACKEND_SERVICE)\n .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, LOCALITY)\n .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SECURITY_LEVEL)\n .build();\n List<EquivalentAddressGroup> addressGroups =\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr), eagAttributes));\n InternalLogId logId = InternalLogId.allocate(\"Subchannel\", /*details=*/ AUTHORITY);\n ChannelTracer subchannelTracer = new ChannelTracer(logId, 10,\n fakeClock.getTimeProvider().currentTimeNanos(), \"Subchannel\");\n LoadBalancer.CreateSubchannelArgs createSubchannelArgs =\n LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(addressGroups).build();\n internalSubchannel = new InternalSubchannel(\n createSubchannelArgs, AUTHORITY, USER_AGENT, mockBackoffPolicyProvider,\n mockTransportFactory, fakeClock.getScheduledExecutorService(),\n fakeClock.getStopwatchSupplier(), syncContext, mockInternalSubchannelCallback, channelz,\n CallTracer.getDefaultFactory().create(), subchannelTracer, logId,\n new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()),\n Collections.emptyList(), AUTHORITY, mockMetricRecorder\n );\n\n // --- Action: Simulate the \"connecting to failed\" transition ---\n // a. Initiate the connection attempt. The subchannel is now CONNECTING.\n internalSubchannel.obtainActiveTransport();\n MockClientTransportInfo transportInfo = transports.poll();\n assertNotNull(\"A connection attempt should have been made\", transportInfo);\n\n // b. Fail the transport before it can signal `transportReady()`.\n transportInfo.listener.transportShutdown(\n Status.INTERNAL.withDescription(\"Simulated connect failure\"),\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n fakeClock.runDueTasks(); // Process the failure event\n\n // --- Verification ---\n // a. Verify that the \"connection_attempts_failed\" metric was recorded exactly once.\n verify(mockMetricRecorder).addLongCounter(\n eqMetricInstrumentName(\"grpc.subchannel.connection_attempts_failed\"),\n eq(1L),\n eq(Arrays.asList(AUTHORITY)),\n eq(Arrays.asList(BACKEND_SERVICE, LOCALITY))\n );\n\n // b. Verify no other metrics were recorded. This confirms it wasn't incorrectly\n // logged as a success, disconnection, or open connection.\n verifyNoMoreInteractions(mockMetricRecorder);\n }\n\n @Test\n public void subchannelStateChanges_triggersSuccessAndDisconnectMetrics() {\n // 1. Mock the backoff policy (needed for subchannel creation)\n when(mockBackoffPolicyProvider.get()).thenReturn(mockBackoffPolicy);\n\n // 2. Setup Subchannel with attributes\n SocketAddress addr = mock(SocketAddress.class);\n Attributes eagAttributes = Attributes.newBuilder()\n .set(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE, BACKEND_SERVICE)\n .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, LOCALITY)\n .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SECURITY_LEVEL)\n .build();\n List<EquivalentAddressGroup> addressGroups =\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr), eagAttributes));\n createInternalSubchannel(new EquivalentAddressGroup(addr));\n InternalLogId logId = InternalLogId.allocate(\"Subchannel\", /*details=*/ AUTHORITY);\n ChannelTracer subchannelTracer = new ChannelTracer(logId, 10,\n fakeClock.getTimeProvider().currentTimeNanos(), \"Subchannel\");\n LoadBalancer.CreateSubchannelArgs createSubchannelArgs =\n LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(addressGroups).build();\n internalSubchannel = new InternalSubchannel(\n createSubchannelArgs, AUTHORITY, USER_AGENT, mockBackoffPolicyProvider,\n mockTransportFactory, fakeClock.getScheduledExecutorService(),\n fakeClock.getStopwatchSupplier(), syncContext, mockInternalSubchannelCallback, channelz,\n CallTracer.getDefaultFactory().create(), subchannelTracer, logId,\n new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()),\n Collections.emptyList(), AUTHORITY, mockMetricRecorder\n );\n\n // --- Action: Successful connection ---\n internalSubchannel.obtainActiveTransport();\n MockClientTransportInfo transportInfo = transports.poll();\n assertNotNull(transportInfo);\n transportInfo.listener.transportReady();\n fakeClock.runDueTasks(); // Process the successful connection\n\n // --- Action: Transport is shut down ---\n transportInfo.listener.transportShutdown(Status.UNAVAILABLE.withDescription(\"unknown\"),\n SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);\n fakeClock.runDueTasks(); // Process the shutdown\n\n // --- Verification ---\n InOrder inOrder = inOrder(mockMetricRecorder);\n\n // Verify successful connection metrics\n inOrder.verify(mockMetricRecorder).addLongCounter(\n eqMetricInstrumentName(\"grpc.subchannel.connection_attempts_succeeded\"),\n eq(1L),\n eq(Arrays.asList(AUTHORITY)),\n eq(Arrays.asList(BACKEND_SERVICE, LOCALITY))\n );\n inOrder.verify(mockMetricRecorder).addLongUpDownCounter(\n eqMetricInstrumentName(\"grpc.subchannel.open_connections\"),\n eq(1L),\n eq(Arrays.asList(AUTHORITY)),\n eq(Arrays.asList(\"privacy_and_integrity\", BACKEND_SERVICE, LOCALITY))\n );\n\n // Verify disconnection metrics\n inOrder.verify(mockMetricRecorder).addLongCounter(\n eqMetricInstrumentName(\"grpc.subchannel.disconnections\"),\n eq(1L),\n eq(Arrays.asList(AUTHORITY)),\n eq(Arrays.asList(BACKEND_SERVICE, LOCALITY, \"subchannel shutdown\"))\n );\n inOrder.verify(mockMetricRecorder).addLongUpDownCounter(\n eqMetricInstrumentName(\"grpc.subchannel.open_connections\"),\n eq(-1L),\n eq(Arrays.asList(AUTHORITY)),\n eq(Arrays.asList(\"privacy_and_integrity\", BACKEND_SERVICE, LOCALITY))\n );\n\n inOrder.verifyNoMoreInteractions();\n }\n\n @Test\n public void subchannelStateChanges_backendServiceFallsBackToResolutionResultAttr() {\n when(mockBackoffPolicyProvider.get()).thenReturn(mockBackoffPolicy);\n SocketAddress addr = mock(SocketAddress.class);\n Attributes eagAttributes = Attributes.newBuilder()\n .set(NameResolver.ATTR_BACKEND_SERVICE, BACKEND_SERVICE)\n .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, LOCALITY)\n .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SECURITY_LEVEL)\n .build();\n List<EquivalentAddressGroup> addressGroups =\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr), eagAttributes));\n InternalLogId logId = InternalLogId.allocate(\"Subchannel\", /*details=*/ AUTHORITY);\n ChannelTracer subchannelTracer = new ChannelTracer(logId, 10,\n fakeClock.getTimeProvider().currentTimeNanos(), \"Subchannel\");\n LoadBalancer.CreateSubchannelArgs createSubchannelArgs =\n LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(addressGroups).build();\n internalSubchannel = new InternalSubchannel(\n createSubchannelArgs, AUTHORITY, USER_AGENT, mockBackoffPolicyProvider,\n mockTransportFactory, fakeClock.getScheduledExecutorService(),\n fakeClock.getStopwatchSupplier(), syncContext, mockInternalSubchannelCallback, channelz,\n CallTracer.getDefaultFactory().create(), subchannelTracer, logId,\n new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()),\n Collections.emptyList(), AUTHORITY, mockMetricRecorder\n );\n\n internalSubchannel.obtainActiveTransport();\n MockClientTransportInfo transportInfo = transports.poll();\n assertNotNull(transportInfo);\n transportInfo.listener.transportReady();\n fakeClock.runDueTasks();\n\n verify(mockMetricRecorder).addLongCounter(\n eqMetricInstrumentName(\"grpc.subchannel.connection_attempts_succeeded\"),\n eq(1L),\n eq(Arrays.asList(AUTHORITY)),\n eq(Arrays.asList(BACKEND_SERVICE, LOCALITY))\n );\n }\n\n private void assertNoCallbackInvoke() {\n while (fakeExecutor.runDueTasks() > 0) {}\n assertEquals(0, callbackInvokes.size());\n }\n\n private void assertExactCallbackInvokes(String ... expectedInvokes) {\n assertEquals(Arrays.asList(expectedInvokes), callbackInvokes);\n callbackInvokes.clear();\n }\n\n static class MetricRecorderImpl implements MetricRecorder {\n }\n\n @SuppressWarnings(\"TypeParameterUnusedInFormals\")\n private <T extends MetricInstrument> T eqMetricInstrumentName(String name) {\n return argThat(instrument -> instrument.getName().equals(name));\n }\n\n private static class FakeSocketAddress extends SocketAddress {}\n}\n"}, {"path": "xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java", "content": "/*\n * Copyright 2020 The gRPC Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage io.grpc.xds;\n\nimport static com.google.common.truth.Truth.assertThat;\nimport static io.grpc.xds.XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME;\nimport static io.grpc.xds.XdsLbPolicies.PRIORITY_POLICY_NAME;\nimport static io.grpc.xds.XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME;\nimport static io.grpc.xds.XdsLbPolicies.WRR_LOCALITY_POLICY_NAME;\nimport static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_CDS;\nimport static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_EDS;\nimport static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_LDS;\nimport static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_RDS;\nimport static java.util.stream.Collectors.toList;\nimport static org.mockito.ArgumentMatchers.any;\nimport static org.mockito.ArgumentMatchers.eq;\nimport static org.mockito.Mockito.doAnswer;\nimport static org.mockito.Mockito.mock;\nimport static org.mockito.Mockito.never;\nimport static org.mockito.Mockito.verify;\nimport static org.mockito.Mockito.when;\n\nimport com.google.common.collect.ImmutableMap;\nimport com.google.common.collect.Iterables;\nimport com.google.protobuf.Any;\nimport com.google.protobuf.Duration;\nimport com.google.protobuf.UInt32Value;\nimport com.google.protobuf.UInt64Value;\nimport io.envoyproxy.envoy.config.cluster.v3.Cluster;\nimport io.envoyproxy.envoy.config.cluster.v3.OutlierDetection;\nimport io.envoyproxy.envoy.config.core.v3.Address;\nimport io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;\nimport io.envoyproxy.envoy.config.core.v3.ConfigSource;\nimport io.envoyproxy.envoy.config.core.v3.HealthStatus;\nimport io.envoyproxy.envoy.config.core.v3.Locality;\nimport io.envoyproxy.envoy.config.core.v3.Metadata;\nimport io.envoyproxy.envoy.config.core.v3.SocketAddress;\nimport io.envoyproxy.envoy.config.core.v3.TransportSocket;\nimport io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;\nimport io.envoyproxy.envoy.config.endpoint.v3.Endpoint;\nimport io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;\nimport io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;\nimport io.envoyproxy.envoy.extensions.transport_sockets.http_11_proxy.v3.Http11ProxyUpstreamTransport;\nimport io.grpc.Attributes;\nimport io.grpc.ChannelLogger;\nimport io.grpc.ConnectivityState;\nimport io.grpc.EquivalentAddressGroup;\nimport io.grpc.HttpConnectProxiedSocketAddress;\nimport io.grpc.InternalEquivalentAddressGroup;\nimport io.grpc.LoadBalancer;\nimport io.grpc.LoadBalancer.Helper;\nimport io.grpc.LoadBalancer.PickResult;\nimport io.grpc.LoadBalancer.PickSubchannelArgs;\nimport io.grpc.LoadBalancer.ResolvedAddresses;\nimport io.grpc.LoadBalancer.Subchannel;\nimport io.grpc.LoadBalancer.SubchannelPicker;\nimport io.grpc.LoadBalancerProvider;\nimport io.grpc.LoadBalancerRegistry;\nimport io.grpc.NameResolver;\nimport io.grpc.NameResolver.ServiceConfigParser;\nimport io.grpc.NameResolverProvider;\nimport io.grpc.NameResolverRegistry;\nimport io.grpc.Status;\nimport io.grpc.StatusOr;\nimport io.grpc.SynchronizationContext;\nimport io.grpc.inprocess.InProcessChannelBuilder;\nimport io.grpc.inprocess.InProcessServerBuilder;\nimport io.grpc.internal.FakeClock;\nimport io.grpc.internal.GrpcUtil;\nimport io.grpc.testing.GrpcCleanupRule;\nimport io.grpc.util.GracefulSwitchLoadBalancerAccessor;\nimport io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig;\nimport io.grpc.util.OutlierDetectionLoadBalancerProvider;\nimport io.grpc.xds.CdsLoadBalancerProvider.CdsConfig;\nimport io.grpc.xds.ClusterImplLoadBalancerProvider.ClusterImplConfig;\nimport io.grpc.xds.Endpoints.DropOverload;\nimport io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;\nimport io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;\nimport io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;\nimport io.grpc.xds.RingHashLoadBalancer.RingHashConfig;\nimport io.grpc.xds.WrrLocalityLoadBalancer.WrrLocalityConfig;\nimport io.grpc.xds.client.BackendMetricPropagation;\nimport io.grpc.xds.client.Bootstrapper.ServerInfo;\nimport io.grpc.xds.client.LoadStatsManager2;\nimport io.grpc.xds.client.XdsClient;\nimport io.grpc.xds.internal.XdsInternalAttributes;\nimport java.net.InetSocketAddress;\nimport java.net.URI;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.Iterator;\nimport java.util.List;\nimport java.util.concurrent.TimeUnit;\nimport javax.annotation.Nullable;\nimport org.junit.After;\nimport org.junit.Before;\nimport org.junit.Rule;\nimport org.junit.Test;\nimport org.junit.runner.RunWith;\nimport org.junit.runners.JUnit4;\nimport org.mockito.ArgumentCaptor;\nimport org.mockito.Captor;\nimport org.mockito.Mock;\nimport org.mockito.junit.MockitoJUnit;\nimport org.mockito.junit.MockitoRule;\n\n/** Tests for {@link ClusterResolverLoadBalancer}. */\n@RunWith(JUnit4.class)\npublic class ClusterResolverLoadBalancerTest {\n @Rule public final MockitoRule mocks = MockitoJUnit.rule();\n @Rule\n public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();\n\n private static final String SERVER_NAME = \"example.com\";\n private static final String CLUSTER = \"cluster-foo.googleapis.com\";\n private static final String EDS_SERVICE_NAME = \"backend-service-foo.googleapis.com\";\n private static final String DNS_HOST_NAME = \"dns-service.googleapis.com\";\n private static final Cluster EDS_CLUSTER = Cluster.newBuilder()\n .setName(CLUSTER)\n .setType(Cluster.DiscoveryType.EDS)\n .setEdsClusterConfig(Cluster.EdsClusterConfig.newBuilder()\n .setServiceName(EDS_SERVICE_NAME)\n .setEdsConfig(ConfigSource.newBuilder()\n .setAds(AggregatedConfigSource.newBuilder())))\n .build();\n private static final Cluster LOGICAL_DNS_CLUSTER = Cluster.newBuilder()\n .setName(CLUSTER)\n .setType(Cluster.DiscoveryType.LOGICAL_DNS)\n .setLoadAssignment(ClusterLoadAssignment.newBuilder()\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .addLbEndpoints(newSocketLbEndpoint(DNS_HOST_NAME, 9000))))\n .build();\n private static final Locality LOCALITY1 = Locality.newBuilder()\n .setRegion(\"test-region-1\")\n .setZone(\"test-zone-1\")\n .setSubZone(\"test-subzone-1\")\n .build();\n private static final Locality LOCALITY2 = Locality.newBuilder()\n .setRegion(\"test-region-2\")\n .setZone(\"test-zone-2\")\n .setSubZone(\"test-subzone-2\")\n .build();\n private static final Locality LOCALITY3 = Locality.newBuilder()\n .setRegion(\"test-region-3\")\n .setZone(\"test-zone-3\")\n .setSubZone(\"test-subzone-3\")\n .build();\n\n private final SynchronizationContext syncContext = new SynchronizationContext(\n new Thread.UncaughtExceptionHandler() {\n @Override\n public void uncaughtException(Thread t, Throwable e) {\n throw new AssertionError(e);\n }\n });\n private final FakeClock fakeClock = new FakeClock();\n private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();\n private final NameResolverRegistry nsRegistry = new NameResolverRegistry();\n private final List<FakeLoadBalancer> childBalancers = new ArrayList<>();\n private final List<FakeNameResolver> resolvers = new ArrayList<>();\n private final XdsTestControlPlaneService controlPlaneService = new XdsTestControlPlaneService();\n private final XdsClient xdsClient = XdsTestUtils.createXdsClient(\n Arrays.asList(\"control-plane.example.com\"),\n serverInfo -> new GrpcXdsTransportFactory.GrpcXdsTransport(\n InProcessChannelBuilder\n .forName(serverInfo.target())\n .directExecutor()\n .build()),\n fakeClock);\n\n\n private XdsDependencyManager xdsDepManager;\n @Mock\n private Helper helper;\n @Captor\n private ArgumentCaptor<SubchannelPicker> pickerCaptor;\n private CdsLoadBalancer2 loadBalancer;\n private boolean originalIsEnabledXdsHttpConnect;\n\n @Before\n public void setUp() throws Exception {\n lbRegistry.register(new RingHashLoadBalancerProvider());\n lbRegistry.register(new WrrLocalityLoadBalancerProvider());\n lbRegistry.register(new FakeLoadBalancerProvider(PRIORITY_POLICY_NAME));\n lbRegistry.register(new FakeLoadBalancerProvider(CLUSTER_IMPL_POLICY_NAME));\n lbRegistry.register(new FakeLoadBalancerProvider(WEIGHTED_TARGET_POLICY_NAME));\n lbRegistry.register(\n new FakeLoadBalancerProvider(\"pick_first\")); // needed by logical_dns\n lbRegistry.register(new OutlierDetectionLoadBalancerProvider());\n NameResolver.Args args = NameResolver.Args.newBuilder()\n .setDefaultPort(8080)\n .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)\n .setSynchronizationContext(syncContext)\n .setServiceConfigParser(mock(ServiceConfigParser.class))\n .setChannelLogger(mock(ChannelLogger.class))\n .setScheduledExecutorService(fakeClock.getScheduledExecutorService())\n .setNameResolverRegistry(nsRegistry)\n .build();\n\n xdsDepManager = new XdsDependencyManager(\n xdsClient,\n syncContext,\n SERVER_NAME,\n SERVER_NAME,\n args);\n\n cleanupRule.register(InProcessServerBuilder\n .forName(\"control-plane.example.com\")\n .addService(controlPlaneService)\n .directExecutor()\n .build()\n .start());\n\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS, ImmutableMap.of(\n SERVER_NAME, ControlPlaneRule.buildClientListener(SERVER_NAME, \"my-route\")));\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_RDS, ImmutableMap.of(\n \"my-route\", XdsTestUtils.buildRouteConfiguration(SERVER_NAME, \"my-route\", CLUSTER)));\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, EDS_CLUSTER));\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, ControlPlaneRule.buildClusterLoadAssignment(\n \"127.0.0.1\", \"\", 8080, EDS_SERVICE_NAME)));\n\n nsRegistry.register(new FakeNameResolverProvider());\n when(helper.getAuthority()).thenReturn(\"api.google.com\");\n doAnswer((inv) -> {\n xdsDepManager.requestReresolution();\n return null;\n }).when(helper).refreshNameResolution();\n loadBalancer = new CdsLoadBalancer2(helper, lbRegistry);\n\n originalIsEnabledXdsHttpConnect = XdsClusterResource.isEnabledXdsHttpConnect;\n }\n\n @After\n public void tearDown() throws Exception {\n XdsClusterResource.isEnabledXdsHttpConnect = originalIsEnabledXdsHttpConnect;\n loadBalancer.shutdown();\n if (xdsDepManager != null) {\n xdsDepManager.shutdown();\n }\n assertThat(xdsClient.getSubscribedResourcesMetadataSnapshot().get()).isEmpty();\n xdsClient.shutdown();\n assertThat(childBalancers).isEmpty();\n assertThat(resolvers).isEmpty();\n assertThat(fakeClock.getPendingTasks()).isEmpty();\n }\n\n @Test\n public void edsClustersWithRingHashEndpointLbPolicy_oppositePickFirstWeightedShuffling()\n throws Exception {\n boolean original = CdsLoadBalancer2.pickFirstWeightedShuffling;\n CdsLoadBalancer2.pickFirstWeightedShuffling = !CdsLoadBalancer2.pickFirstWeightedShuffling;\n try {\n edsClustersWithRingHashEndpointLbPolicy();\n } finally {\n CdsLoadBalancer2.pickFirstWeightedShuffling = original;\n }\n }\n\n @Test\n public void edsClustersWithRingHashEndpointLbPolicy() throws Exception {\n boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;\n LoadStatsManager2.isEnabledOrcaLrsPropagation = true;\n List<String> metricSpecs = Arrays.asList(\"cpu_utilization\");\n BackendMetricPropagation backendMetricPropagation =\n BackendMetricPropagation.fromMetricSpecs(metricSpecs);\n Cluster cluster = EDS_CLUSTER.toBuilder()\n .setLbPolicy(Cluster.LbPolicy.RING_HASH)\n .setRingHashLbConfig(Cluster.RingHashLbConfig.newBuilder()\n .setMinimumRingSize(UInt64Value.of(10))\n .setMaximumRingSize(UInt64Value.of(100))\n .build())\n .addAllLrsReportEndpointMetrics(metricSpecs)\n .build();\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(10))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8080))\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.2\", 8080)))\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(50))\n .setLocality(LOCALITY2)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.1.1\", 8080)\n .setLoadBalancingWeight(UInt32Value.of(60))))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, cluster));\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(childBalancer.addresses).hasSize(3);\n EquivalentAddressGroup addr1 = childBalancer.addresses.get(0);\n EquivalentAddressGroup addr2 = childBalancer.addresses.get(1);\n EquivalentAddressGroup addr3 = childBalancer.addresses.get(2);\n // Endpoints in LOCALITY1 have no endpoint-level weight specified, so all endpoints within\n // LOCALITY1 are equally weighted.\n assertThat(addr1.getAddresses())\n .isEqualTo(Arrays.asList(newInetSocketAddress(\"127.0.0.1\", 8080)));\n assertThat(addr1.getAttributes().get(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE))\n .isEqualTo(CLUSTER);\n assertThat(addr1.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))\n .isEqualTo(CdsLoadBalancer2.pickFirstWeightedShuffling ? 0x0AAAAAAA /* 1/12 */ : 10);\n assertThat(addr2.getAddresses())\n .isEqualTo(Arrays.asList(newInetSocketAddress(\"127.0.0.2\", 8080)));\n assertThat(addr2.getAttributes().get(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE))\n .isEqualTo(CLUSTER);\n assertThat(addr2.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))\n .isEqualTo(CdsLoadBalancer2.pickFirstWeightedShuffling ? 0x0AAAAAAA /* 1/12 */ : 10);\n assertThat(addr3.getAddresses())\n .isEqualTo(Arrays.asList(newInetSocketAddress(\"127.0.1.1\", 8080)));\n assertThat(addr3.getAttributes().get(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE))\n .isEqualTo(CLUSTER);\n assertThat(addr3.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))\n .isEqualTo(CdsLoadBalancer2.pickFirstWeightedShuffling ? 0x6AAAAAAA /* 5/6 */ : 50 * 60);\n assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);\n PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;\n assertThat(priorityLbConfig.priorities).containsExactly(CLUSTER + \"[child1]\");\n PriorityChildConfig priorityChildConfig =\n Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());\n assertThat(priorityChildConfig.ignoreReresolution).isTrue();\n assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)\n .getPolicyName())\n .isEqualTo(CLUSTER_IMPL_POLICY_NAME);\n ClusterImplConfig clusterImplConfig = (ClusterImplConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);\n assertClusterImplConfig(clusterImplConfig, CLUSTER, EDS_SERVICE_NAME, null, null,\n null, Collections.emptyList(), \"ring_hash_experimental\");\n assertThat(clusterImplConfig.backendMetricPropagation).isEqualTo(backendMetricPropagation);\n LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;\n RingHashConfig ringHashConfig = (RingHashConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig.childConfig);\n assertThat(ringHashConfig.minRingSize).isEqualTo(10L);\n assertThat(ringHashConfig.maxRingSize).isEqualTo(100L);\n }\n\n @Test\n public void edsClustersWithLeastRequestEndpointLbPolicy() {\n Cluster cluster = EDS_CLUSTER.toBuilder()\n .setLbPolicy(Cluster.LbPolicy.LEAST_REQUEST)\n .build();\n // Simple case with one priority and one locality\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8080)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, cluster));\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(childBalancer.addresses).hasSize(1);\n EquivalentAddressGroup addr = childBalancer.addresses.get(0);\n assertThat(addr.getAddresses())\n .isEqualTo(Arrays.asList(newInetSocketAddress(\"127.0.0.1\", 8080)));\n assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);\n PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;\n assertThat(priorityLbConfig.priorities).containsExactly(CLUSTER + \"[child1]\");\n PriorityChildConfig priorityChildConfig =\n Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());\n assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)\n .getPolicyName())\n .isEqualTo(CLUSTER_IMPL_POLICY_NAME);\n ClusterImplConfig clusterImplConfig = (ClusterImplConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);\n assertClusterImplConfig(clusterImplConfig, CLUSTER, EDS_SERVICE_NAME, null, null,\n null, Collections.emptyList(), WRR_LOCALITY_POLICY_NAME);\n WrrLocalityConfig wrrLocalityConfig = (WrrLocalityConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig.childConfig);\n LoadBalancerProvider childProvider =\n GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig.childConfig);\n assertThat(childProvider.getPolicyName()).isEqualTo(\"least_request_experimental\");\n\n assertThat(\n childBalancer.addresses.get(0).getAttributes()\n .get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY_WEIGHT)).isEqualTo(100);\n }\n\n @Test\n public void edsClustersEndpointHostname_addedToAddressAttribute() {\n // Simple case with one priority and one locality\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(LbEndpoint.newBuilder()\n .setEndpoint(Endpoint.newBuilder()\n .setHostname(\"hostname1\")\n .setAddress(newAddress(\"127.0.0.1\", 8000)))))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n\n assertThat(\n childBalancer.addresses.get(0).getAttributes()\n .get(XdsInternalAttributes.ATTR_ADDRESS_NAME)).isEqualTo(\"hostname1\");\n }\n\n @Test\n public void endpointAddressRewritten_whenProxyMetadataIsInEndpointMetadata() {\n XdsClusterResource.isEnabledXdsHttpConnect = true;\n Cluster cluster = EDS_CLUSTER.toBuilder()\n .setTransportSocket(TransportSocket.newBuilder()\n .setName(\n \"type.googleapis.com/\" + Http11ProxyUpstreamTransport.getDescriptor().getFullName())\n .setTypedConfig(Any.pack(Http11ProxyUpstreamTransport.getDefaultInstance())))\n .build();\n // Proxy address in endpointMetadata, and no proxy in locality metadata\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8080)\n .setMetadata(Metadata.newBuilder()\n .putTypedFilterMetadata(\n \"envoy.http11_proxy_transport_socket.proxy_address\",\n Any.pack(newAddress(\"127.0.0.2\", 8081).build()))))\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.3\", 8082)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, cluster));\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n\n // Get the rewritten address\n java.net.SocketAddress rewrittenAddress =\n childBalancer.addresses.get(0).getAddresses().get(0);\n assertThat(rewrittenAddress).isInstanceOf(HttpConnectProxiedSocketAddress.class);\n HttpConnectProxiedSocketAddress proxiedSocket =\n (HttpConnectProxiedSocketAddress) rewrittenAddress;\n\n // Assert that the target address is the original address\n assertThat(proxiedSocket.getTargetAddress()).isEqualTo(newInetSocketAddress(\"127.0.0.1\", 8080));\n\n // Assert that the proxy address is correctly set\n assertThat(proxiedSocket.getProxyAddress()).isEqualTo(newInetSocketAddress(\"127.0.0.2\", 8081));\n\n // Check the non-rewritten address\n java.net.SocketAddress normalAddress = childBalancer.addresses.get(1).getAddresses().get(0);\n assertThat(normalAddress).isEqualTo(newInetSocketAddress(\"127.0.0.3\", 8082));\n }\n\n @Test\n public void endpointAddressRewritten_whenProxyMetadataIsInLocalityMetadata() {\n XdsClusterResource.isEnabledXdsHttpConnect = true;\n Cluster cluster = EDS_CLUSTER.toBuilder()\n .setTransportSocket(TransportSocket.newBuilder()\n .setName(\n \"type.googleapis.com/\" + Http11ProxyUpstreamTransport.getDescriptor().getFullName())\n .setTypedConfig(Any.pack(Http11ProxyUpstreamTransport.getDefaultInstance())))\n .build();\n // No proxy address in endpointMetadata, and proxy in locality metadata\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8080))\n .setMetadata(Metadata.newBuilder()\n .putTypedFilterMetadata(\n \"envoy.http11_proxy_transport_socket.proxy_address\",\n Any.pack(newAddress(\"127.0.0.2\", 8081).build()))))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, cluster));\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n\n // Get the rewritten address\n java.net.SocketAddress rewrittenAddress = childBalancer.addresses.get(0).getAddresses().get(0);\n\n // Assert that the address was rewritten\n assertThat(rewrittenAddress).isInstanceOf(HttpConnectProxiedSocketAddress.class);\n HttpConnectProxiedSocketAddress proxiedSocket =\n (HttpConnectProxiedSocketAddress) rewrittenAddress;\n\n // Assert that the target address is the original address\n assertThat(proxiedSocket.getTargetAddress()).isEqualTo(newInetSocketAddress(\"127.0.0.1\", 8080));\n\n // Assert that the proxy address is correctly set from locality metadata\n assertThat(proxiedSocket.getProxyAddress()).isEqualTo(newInetSocketAddress(\"127.0.0.2\", 8081));\n }\n\n @Test\n public void onlyEdsClusters_receivedEndpoints() {\n // Has two localities with different priorities\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(70))\n .setPriority(0)\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8080))\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.2\", 8080)))\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(30))\n .setPriority(1)\n .setLocality(LOCALITY2)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.3\", 8080)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n String priority1 = CLUSTER + \"[child1]\";\n String priority2 = CLUSTER + \"[child2]\";\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);\n PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;\n assertThat(priorityLbConfig.priorities)\n .containsExactly(priority1, priority2).inOrder();\n\n PriorityChildConfig priorityChildConfig1 = priorityLbConfig.childConfigs.get(priority1);\n assertThat(priorityChildConfig1.ignoreReresolution).isTrue();\n assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig1.childConfig)\n .getPolicyName())\n .isEqualTo(CLUSTER_IMPL_POLICY_NAME);\n ClusterImplConfig clusterImplConfig1 = (ClusterImplConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig1.childConfig);\n assertClusterImplConfig(clusterImplConfig1, CLUSTER, EDS_SERVICE_NAME, null, null,\n null, Collections.emptyList(), WRR_LOCALITY_POLICY_NAME);\n WrrLocalityConfig wrrLocalityConfig1 = (WrrLocalityConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig1.childConfig);\n LoadBalancerProvider childProvider1 =\n GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig1.childConfig);\n assertThat(childProvider1.getPolicyName()).isEqualTo(\"round_robin\");\n\n PriorityChildConfig priorityChildConfig2 = priorityLbConfig.childConfigs.get(priority2);\n assertThat(priorityChildConfig2.ignoreReresolution).isTrue();\n assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig2.childConfig)\n .getPolicyName())\n .isEqualTo(CLUSTER_IMPL_POLICY_NAME);\n ClusterImplConfig clusterImplConfig2 = (ClusterImplConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig2.childConfig);\n assertClusterImplConfig(clusterImplConfig2, CLUSTER, EDS_SERVICE_NAME, null, null,\n null, Collections.emptyList(), WRR_LOCALITY_POLICY_NAME);\n WrrLocalityConfig wrrLocalityConfig2 = (WrrLocalityConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig1.childConfig);\n LoadBalancerProvider childProvider2 =\n GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig2.childConfig);\n assertThat(childProvider2.getPolicyName()).isEqualTo(\"round_robin\");\n\n WrrLocalityConfig wrrLocalityConfig3 = (WrrLocalityConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig1.childConfig);\n LoadBalancerProvider childProvider3 =\n GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig3.childConfig);\n assertThat(childProvider3.getPolicyName()).isEqualTo(\"round_robin\");\n\n io.grpc.xds.client.Locality locality1 = io.grpc.xds.client.Locality.create(\n LOCALITY1.getRegion(), LOCALITY1.getZone(), LOCALITY1.getSubZone());\n io.grpc.xds.client.Locality locality2 = io.grpc.xds.client.Locality.create(\n LOCALITY2.getRegion(), LOCALITY2.getZone(), LOCALITY2.getSubZone());\n for (EquivalentAddressGroup eag : childBalancer.addresses) {\n io.grpc.xds.client.Locality locality =\n eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY);\n if (locality.equals(locality1)) {\n assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY_WEIGHT))\n .isEqualTo(70);\n } else if (locality.equals(locality2)) {\n assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY_WEIGHT))\n .isEqualTo(30);\n } else {\n throw new AssertionError(\"Unexpected locality region: \" + locality.region());\n }\n }\n }\n\n @SuppressWarnings(\"unchecked\")\n private void verifyEdsPriorityNames(List<String> want, List<LocalityLbEndpoints>... updates) {\n Iterator<ClusterLoadAssignment> edsUpdates = Arrays.asList(updates).stream()\n .map(update -> ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addAllEndpoints(update)\n .build())\n .iterator();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, edsUpdates.next()));\n startXdsDepManager();\n\n while (edsUpdates.hasNext()) {\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, edsUpdates.next()));\n }\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);\n PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;\n assertThat(priorityLbConfig.priorities).isEqualTo(want);\n }\n\n @Test\n @SuppressWarnings(\"unchecked\")\n public void edsUpdatePriorityName_twoPriorities() {\n verifyEdsPriorityNames(Arrays.asList(CLUSTER + \"[child1]\", CLUSTER + \"[child2]\"),\n Arrays.asList(createEndpoints(LOCALITY1, 0), createEndpoints(LOCALITY2, 1)));\n }\n\n @Test\n @SuppressWarnings(\"unchecked\")\n public void edsUpdatePriorityName_addOnePriority() {\n verifyEdsPriorityNames(Arrays.asList(CLUSTER + \"[child2]\"),\n Arrays.asList(createEndpoints(LOCALITY1, 0)),\n Arrays.asList(createEndpoints(LOCALITY2, 0)));\n }\n\n @Test\n @SuppressWarnings(\"unchecked\")\n public void edsUpdatePriorityName_swapTwoPriorities() {\n verifyEdsPriorityNames(Arrays.asList(CLUSTER + \"[child2]\", CLUSTER + \"[child1]\",\n CLUSTER + \"[child3]\"),\n Arrays.asList(\n createEndpoints(LOCALITY1, 0),\n createEndpoints(LOCALITY2, 1),\n createEndpoints(LOCALITY3, 2)),\n Arrays.asList(\n createEndpoints(LOCALITY1, 1),\n createEndpoints(LOCALITY2, 0),\n createEndpoints(LOCALITY3, 2)));\n }\n\n @Test\n @SuppressWarnings(\"unchecked\")\n public void edsUpdatePriorityName_mergeTwoPriorities() {\n verifyEdsPriorityNames(Arrays.asList(CLUSTER + \"[child3]\", CLUSTER + \"[child1]\"),\n Arrays.asList(\n createEndpoints(LOCALITY1, 0),\n createEndpoints(LOCALITY3, 2),\n createEndpoints(LOCALITY2, 1)),\n Arrays.asList(\n createEndpoints(LOCALITY1, 1),\n createEndpoints(LOCALITY3, 0),\n createEndpoints(LOCALITY2, 0)));\n }\n\n private LocalityLbEndpoints createEndpoints(Locality locality, int priority) {\n return LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(70))\n .setLocality(locality)\n .setPriority(priority)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.\" + priority + \".1\", 8080))\n .build();\n }\n\n @Test\n public void onlyEdsClusters_resourceNeverExist_returnErrorPicker() {\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());\n startXdsDepManager();\n\n verify(helper).updateBalancingState(\n eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());\n String expectedDescription = \"Error retrieving CDS resource \" + CLUSTER + \": NOT_FOUND. \"\n + \"Details: Timed out waiting for resource \" + CLUSTER + \" from xDS server nodeID: node-id\";\n Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);\n assertPicker(pickerCaptor.getValue(), expectedError, null);\n }\n\n @Test\n public void cdsMissing_handledDirectly() {\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8000)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n\n startXdsDepManager();\n assertThat(childBalancers).hasSize(0); // no child LB policy created\n verify(helper).updateBalancingState(\n eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());\n String expectedDescription = \"Error retrieving CDS resource \" + CLUSTER + \": NOT_FOUND. \"\n + \"Details: Timed out waiting for resource \" + CLUSTER + \" from xDS server nodeID: node-id\";\n Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);\n assertPicker(pickerCaptor.getValue(), expectedError, null);\n assertPicker(pickerCaptor.getValue(), expectedError, null);\n }\n\n @Test\n public void cdsRevoked_handledDirectly() {\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8000)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n\n startXdsDepManager();\n assertThat(childBalancers).hasSize(1); // child LB policy created\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(((PriorityLbConfig) childBalancer.config).priorities).hasSize(1);\n assertThat(childBalancer.addresses).hasSize(1);\n assertAddressesEqual(\n Arrays.asList(newInetSocketAddressEag(\"127.0.0.1\", 8000)),\n childBalancer.addresses);\n\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());\n verify(helper).updateBalancingState(\n eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());\n String expectedDescription = \"Error retrieving CDS resource \" + CLUSTER + \": NOT_FOUND. \"\n + \"Details: Resource \" + CLUSTER + \" does not exist nodeID: node-id\";\n Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);\n assertPicker(pickerCaptor.getValue(), expectedError, null);\n assertThat(childBalancer.shutdown).isTrue();\n }\n\n @Test\n public void edsMissing_failsRpcs() {\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of());\n\n startXdsDepManager();\n assertThat(childBalancers).hasSize(0); // Graceful switch handles it, so no child policies yet\n verify(helper).updateBalancingState(\n eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());\n String expectedDescription = \"Error retrieving EDS resource \" + EDS_SERVICE_NAME\n + \": NOT_FOUND. Details: Timed out waiting for resource \" + EDS_SERVICE_NAME\n + \" from xDS server nodeID: node-id\";\n Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);\n assertPicker(pickerCaptor.getValue(), expectedError, null);\n }\n\n @Test\n public void logicalDnsLookupFailed_failsRpcs() {\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, LOGICAL_DNS_CLUSTER));\n startXdsDepManager(new CdsConfig(CLUSTER), /* forwardTime= */ false);\n FakeNameResolver resolver = assertResolverCreated(\"/\" + DNS_HOST_NAME + \":9000\");\n assertThat(childBalancers).isEmpty();\n Status status = Status.UNAVAILABLE.withDescription(\"OH NO! Who would have guessed?\");\n resolver.deliverError(status);\n\n assertThat(childBalancers).hasSize(0); // Graceful switch handles it, so no child policies yet\n verify(helper).updateBalancingState(\n eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());\n assertPicker(pickerCaptor.getValue(), status, null);\n }\n\n @Test\n public void handleEdsResource_ignoreUnhealthyEndpoints() {\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8000)\n .setHealthStatus(HealthStatus.UNHEALTHY))\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.2\", 8000)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertAddressesEqual(\n Arrays.asList(new EquivalentAddressGroup(newInetSocketAddress(\"127.0.0.2\", 8000))),\n childBalancer.addresses);\n }\n\n @Test\n public void handleEdsResource_ignoreLocalitiesWithNoHealthyEndpoints() {\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8000)\n .setHealthStatus(HealthStatus.UNHEALTHY)))\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY2)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.2\", 8000)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n io.grpc.xds.client.Locality locality2 = io.grpc.xds.client.Locality.create(\n LOCALITY2.getRegion(), LOCALITY2.getZone(), LOCALITY2.getSubZone());\n for (EquivalentAddressGroup eag : childBalancer.addresses) {\n assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY))\n .isEqualTo(locality2);\n }\n }\n\n @Test\n public void handleEdsResource_ignorePrioritiesWithNoHealthyEndpoints() {\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .setPriority(0)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8000)\n .setHealthStatus(HealthStatus.UNHEALTHY)))\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY2)\n .setPriority(1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.2\", 8000)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n String priority2 = CLUSTER + \"[child2]\";\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(((PriorityLbConfig) childBalancer.config).priorities).containsExactly(priority2);\n }\n\n @Test\n public void handleEdsResource_noHealthyEndpoint() {\n ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()\n .setClusterName(EDS_SERVICE_NAME)\n .addEndpoints(LocalityLbEndpoints.newBuilder()\n .setLoadBalancingWeight(UInt32Value.of(100))\n .setLocality(LOCALITY1)\n .addLbEndpoints(newSocketLbEndpoint(\"127.0.0.1\", 8000)\n .setHealthStatus(HealthStatus.UNHEALTHY)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(\n EDS_SERVICE_NAME, clusterLoadAssignment));\n startXdsDepManager();\n\n assertThat(childBalancers).hasSize(0); // Graceful switch handles it, so no child policies yet\n verify(helper).updateBalancingState(\n eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());\n Status expectedStatus = Status.UNAVAILABLE\n .withDescription(\"No usable endpoint from cluster: \" + CLUSTER);\n assertPicker(pickerCaptor.getValue(), expectedStatus, null);\n }\n\n @Test\n public void onlyLogicalDnsCluster_endpointsResolved() {\n boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;\n LoadStatsManager2.isEnabledOrcaLrsPropagation = true;\n List<String> metricSpecs = Arrays.asList(\"cpu_utilization\");\n BackendMetricPropagation backendMetricPropagation =\n BackendMetricPropagation.fromMetricSpecs(metricSpecs);\n Cluster logicalDnsClusterWithMetrics = LOGICAL_DNS_CLUSTER.toBuilder()\n .addAllLrsReportEndpointMetrics(metricSpecs)\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, logicalDnsClusterWithMetrics));\n startXdsDepManager(new CdsConfig(CLUSTER), /* forwardTime= */ false);\n FakeNameResolver resolver = assertResolverCreated(\"/\" + DNS_HOST_NAME + \":9000\");\n assertThat(childBalancers).isEmpty();\n resolver.deliverEndpointAddresses(Arrays.asList(\n newInetSocketAddressEag(\"127.0.2.1\", 9000), newInetSocketAddressEag(\"127.0.2.2\", 9000)));\n fakeClock.forwardTime(10, TimeUnit.MINUTES);\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);\n PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;\n String priority = Iterables.getOnlyElement(priorityLbConfig.priorities);\n PriorityChildConfig priorityChildConfig = priorityLbConfig.childConfigs.get(priority);\n assertThat(priorityChildConfig.ignoreReresolution).isFalse();\n assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)\n .getPolicyName())\n .isEqualTo(CLUSTER_IMPL_POLICY_NAME);\n ClusterImplConfig clusterImplConfig = (ClusterImplConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);\n assertClusterImplConfig(clusterImplConfig, CLUSTER, null, null, null, null,\n Collections.<DropOverload>emptyList(), \"wrr_locality_experimental\");\n assertThat(clusterImplConfig.backendMetricPropagation).isEqualTo(backendMetricPropagation);\n LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;\n assertAddressesEqual(\n Arrays.asList(new EquivalentAddressGroup(Arrays.asList(\n newInetSocketAddress(\"127.0.2.1\", 9000), newInetSocketAddress(\"127.0.2.2\", 9000)))),\n childBalancer.addresses);\n assertThat(childBalancer.addresses.get(0).getAttributes()\n .get(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE)).isEqualTo(CLUSTER);\n assertThat(childBalancer.addresses.get(0).getAttributes()\n .get(XdsInternalAttributes.ATTR_ADDRESS_NAME)).isEqualTo(DNS_HOST_NAME + \":9000\");\n }\n\n @Test\n public void onlyLogicalDnsCluster_handleRefreshNameResolution() {\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, LOGICAL_DNS_CLUSTER));\n startXdsDepManager(new CdsConfig(CLUSTER), /* forwardTime= */ false);\n FakeNameResolver resolver = assertResolverCreated(\"/\" + DNS_HOST_NAME + \":9000\");\n assertThat(childBalancers).isEmpty();\n resolver.deliverEndpointAddresses(Arrays.asList(newInetSocketAddressEag(\"127.0.2.1\", 9000)));\n fakeClock.forwardTime(10, TimeUnit.MINUTES);\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(resolver.refreshCount).isEqualTo(0);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n childBalancer.helper.refreshNameResolution();\n assertThat(resolver.refreshCount).isEqualTo(1);\n }\n\n @Test\n public void outlierDetection_disabledConfig() {\n Cluster cluster = EDS_CLUSTER.toBuilder()\n .setOutlierDetection(OutlierDetection.newBuilder()\n .setEnforcingSuccessRate(UInt32Value.of(0))\n .setEnforcingFailurePercentage(UInt32Value.of(0)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, cluster));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);\n PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;\n PriorityChildConfig priorityChildConfig =\n Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());\n OutlierDetectionLoadBalancerConfig outlier = (OutlierDetectionLoadBalancerConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);\n assertThat(outlier.successRateEjection).isNull();\n assertThat(outlier.failurePercentageEjection).isNull();\n }\n\n @Test\n public void outlierDetection_fullConfig() {\n Cluster cluster = EDS_CLUSTER.toBuilder()\n .setLbPolicy(Cluster.LbPolicy.ROUND_ROBIN)\n .setOutlierDetection(OutlierDetection.newBuilder()\n .setInterval(Duration.newBuilder().setNanos(101))\n .setBaseEjectionTime(Duration.newBuilder().setNanos(102))\n .setMaxEjectionTime(Duration.newBuilder().setNanos(103))\n .setMaxEjectionPercent(UInt32Value.of(80))\n .setSuccessRateStdevFactor(UInt32Value.of(105))\n .setEnforcingSuccessRate(UInt32Value.of(81))\n .setSuccessRateMinimumHosts(UInt32Value.of(107))\n .setSuccessRateRequestVolume(UInt32Value.of(108))\n .setFailurePercentageThreshold(UInt32Value.of(82))\n .setEnforcingFailurePercentage(UInt32Value.of(83))\n .setFailurePercentageMinimumHosts(UInt32Value.of(111))\n .setFailurePercentageRequestVolume(UInt32Value.of(112)))\n .build();\n controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(\n CLUSTER, cluster));\n startXdsDepManager();\n\n verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());\n assertThat(childBalancers).hasSize(1);\n FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);\n assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);\n PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;\n PriorityChildConfig priorityChildConfig =\n Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());\n OutlierDetectionLoadBalancerConfig outlier = (OutlierDetectionLoadBalancerConfig)\n GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);\n assertThat(outlier.intervalNanos).isEqualTo(101);\n assertThat(outlier.baseEjectionTimeNanos).isEqualTo(102);\n assertThat(outlier.maxEjectionTimeNanos).isEqualTo(103);\n assertThat(outlier.maxEjectionPercent).isEqualTo(80);\n assertThat(outlier.successRateEjection.stdevFactor).isEqualTo(105);\n assertThat(outlier.successRateEjection.enforcementPercentage).isEqualTo(81);\n assertThat(outlier.successRateEjection.minimumHosts).isEqualTo(107);\n assertThat(outlier.successRateEjection.requestVolume).isEqualTo(108);\n assertThat(outlier.failurePercentageEjection.threshold).isEqualTo(82);\n assertThat(outlier.failurePercentageEjection.enforcementPercentage).isEqualTo(83);\n assertThat(outlier.failurePercentageEjection.minimumHosts).isEqualTo(111);\n assertThat(outlier.failurePercentageEjection.requestVolume).isEqualTo(112);\n assertClusterImplConfig(\n (ClusterImplConfig) GracefulSwitchLoadBalancerAccessor.getChildConfig(outlier.childConfig),\n CLUSTER, EDS_SERVICE_NAME, null, null, null, Collections.emptyList(),\n \"wrr_locality_experimental\");\n }\n\n private void startXdsDepManager() {\n startXdsDepManager(new CdsConfig(CLUSTER));\n }\n\n private void startXdsDepManager(final CdsConfig cdsConfig) {\n startXdsDepManager(cdsConfig, true);\n }\n\n private void startXdsDepManager(final CdsConfig cdsConfig, boolean forwardTime) {\n xdsDepManager.start(\n xdsConfig -> {\n if (!xdsConfig.hasValue()) {\n throw new AssertionError(\"\" + xdsConfig.getStatus());\n }\n if (loadBalancer == null) {\n return;\n }\n loadBalancer.acceptResolvedAddresses(ResolvedAddresses.newBuilder()\n .setAddresses(Collections.emptyList())\n .setAttributes(Attributes.newBuilder()\n .set(io.grpc.xds.XdsAttributes.XDS_CONFIG, xdsConfig.getValue())\n .set(io.grpc.xds.XdsAttributes.XDS_CLUSTER_SUBSCRIPT_REGISTRY, xdsDepManager)\n .build())\n .setLoadBalancingPolicyConfig(cdsConfig)\n .build());\n });\n if (forwardTime) {\n // trigger does not exist timer, so broken config is more obvious\n fakeClock.forwardTime(10, TimeUnit.MINUTES);\n }\n }\n\n private FakeNameResolver assertResolverCreated(String uriPath) {\n assertThat(resolvers).hasSize(1);\n FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);\n assertThat(resolver.targetUri.getPath()).isEqualTo(uriPath);\n return resolver;\n }\n\n private static void assertPicker(SubchannelPicker picker, Status expectedStatus,\n @Nullable Subchannel expectedSubchannel) {\n PickResult result = picker.pickSubchannel(mock(PickSubchannelArgs.class));\n Status actualStatus = result.getStatus();\n assertThat(actualStatus.getCode()).isEqualTo(expectedStatus.getCode());\n assertThat(actualStatus.getDescription()).isEqualTo(expectedStatus.getDescription());\n if (actualStatus.isOk()) {\n assertThat(result.getSubchannel()).isSameInstanceAs(expectedSubchannel);\n }\n }\n\n private static void assertClusterImplConfig(ClusterImplConfig config, String cluster,\n @Nullable String edsServiceName, ServerInfo lrsServerInfo, Long maxConcurrentRequests,\n @Nullable UpstreamTlsContext tlsContext, List<DropOverload> dropCategories,\n String childPolicy) {\n assertThat(config.cluster).isEqualTo(cluster);\n assertThat(config.edsServiceName).isEqualTo(edsServiceName);\n assertThat(config.lrsServerInfo).isEqualTo(lrsServerInfo);\n assertThat(config.maxConcurrentRequests).isEqualTo(maxConcurrentRequests);\n assertThat(config.tlsContext).isEqualTo(tlsContext);\n assertThat(config.dropCategories).isEqualTo(dropCategories);\n assertThat(\n GracefulSwitchLoadBalancerAccessor.getChildProvider(config.childConfig).getPolicyName())\n .isEqualTo(childPolicy);\n }\n\n /** Asserts two list of EAGs contains same addresses, regardless of attributes. */\n private static void assertAddressesEqual(\n List<EquivalentAddressGroup> expected, List<EquivalentAddressGroup> actual) {\n List<List<java.net.SocketAddress>> expectedAddresses\n = expected.stream().map(EquivalentAddressGroup::getAddresses).collect(toList());\n List<List<java.net.SocketAddress>> actualAddresses\n = actual.stream().map(EquivalentAddressGroup::getAddresses).collect(toList());\n assertThat(actualAddresses).isEqualTo(expectedAddresses);\n }\n\n @SuppressWarnings(\"AddressSelection\")\n private static InetSocketAddress newInetSocketAddress(String ip, int port) {\n return new InetSocketAddress(ip, port);\n }\n\n private static EquivalentAddressGroup newInetSocketAddressEag(String ip, int port) {\n return new EquivalentAddressGroup(newInetSocketAddress(ip, port));\n }\n\n private static LbEndpoint.Builder newSocketLbEndpoint(String ip, int port) {\n return LbEndpoint.newBuilder()\n .setEndpoint(Endpoint.newBuilder()\n .setAddress(newAddress(ip, port)))\n .setHealthStatus(HealthStatus.HEALTHY);\n }\n\n private static Address.Builder newAddress(String ip, int port) {\n return Address.newBuilder()\n .setSocketAddress(SocketAddress.newBuilder()\n .setAddress(ip)\n .setPortValue(port));\n }\n\n private class FakeNameResolverProvider extends NameResolverProvider {\n @Override\n public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {\n assertThat(targetUri.getScheme()).isEqualTo(\"dns\");\n FakeNameResolver resolver = new FakeNameResolver(targetUri);\n resolvers.add(resolver);\n return resolver;\n }\n\n @Override\n public String getDefaultScheme() {\n return \"dns\";\n }\n\n @Override\n protected boolean isAvailable() {\n return true;\n }\n\n @Override\n protected int priority() {\n return 0; // doesn't matter\n }\n }\n\n\n private class FakeNameResolver extends NameResolver {\n private final URI targetUri;\n protected Listener2 listener;\n private int refreshCount;\n\n private FakeNameResolver(URI targetUri) {\n this.targetUri = targetUri;\n }\n\n @Override\n public String getServiceAuthority() {\n throw new UnsupportedOperationException(\"should not be called\");\n }\n\n @Override\n public void start(final Listener2 listener) {\n this.listener = listener;\n }\n\n @Override\n public void refresh() {\n refreshCount++;\n }\n\n @Override\n public void shutdown() {\n resolvers.remove(this);\n }\n\n protected void deliverEndpointAddresses(List<EquivalentAddressGroup> addresses) {\n syncContext.execute(() -> {\n Status ret = listener.onResult2(ResolutionResult.newBuilder()\n .setAddressesOrError(StatusOr.fromValue(addresses)).build());\n assertThat(ret.getCode()).isEqualTo(Status.Code.OK);\n });\n }\n\n protected void deliverError(Status error) {\n syncContext.execute(() -> listener.onResult2(ResolutionResult.newBuilder()\n .setAddressesOrError(StatusOr.fromStatus(error)).build()));\n }\n }\n\n private final class FakeLoadBalancerProvider extends LoadBalancerProvider {\n private final String policyName;\n\n FakeLoadBalancerProvider(String policyName) {\n this.policyName = policyName;\n }\n\n @Override\n public LoadBalancer newLoadBalancer(Helper helper) {\n FakeLoadBalancer balancer = new FakeLoadBalancer(policyName, helper);\n childBalancers.add(balancer);\n return balancer;\n }\n\n @Override\n public boolean isAvailable() {\n return true;\n }\n\n @Override\n public int getPriority() {\n return 0; // doesn't matter\n }\n\n @Override\n public String getPolicyName() {\n return policyName;\n }\n }\n\n private final class FakeLoadBalancer extends LoadBalancer {\n private final String name;\n private final Helper helper;\n private List<EquivalentAddressGroup> addresses;\n private Object config;\n private boolean shutdown;\n\n FakeLoadBalancer(String name, Helper helper) {\n this.name = name;\n this.helper = helper;\n }\n\n @Override\n public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {\n addresses = resolvedAddresses.getAddresses();\n config = resolvedAddresses.getLoadBalancingPolicyConfig();\n return Status.OK;\n }\n\n @Override\n public void handleNameResolutionError(Status error) {\n }\n\n @Override\n public void shutdown() {\n shutdown = true;\n childBalancers.remove(this);\n }\n }\n}\n"}], "eval": {"test_cmds": ["./gradlew -Dorg.gradle.parallel=true -Dorg.gradle.jvmargs='-Xmx1g' -PskipAndroid=true -PskipCodegen=true -PerrorProne=false test --info --rerun-tasks"], "print_cmds": [], "log_parser": "def parser(log: str) -> dict[str, str]:\n import re\n import xml.etree.ElementTree as ET\n from typing import Dict, Tuple\n\n # results maps key -> (status, priority)\n results: Dict[str, Tuple[str, int]] = {}\n rank = {\"pass\": 0, \"skip\": 1, \"fail\": 2}\n\n def update(key: str, status: str, priority: int) -> None:\n if not key:\n return\n prev = results.get(key)\n if prev is None:\n results[key] = (status, priority)\n return\n prev_status, prev_priority = prev\n if priority > prev_priority:\n results[key] = (status, priority)\n elif priority == prev_priority and rank[status] > rank.get(prev_status, -1):\n results[key] = (status, priority)\n\n def strip_ns(root: ET.Element) -> ET.Element:\n for elem in root.iter():\n if isinstance(elem.tag, str) and \"}\" in elem.tag:\n elem.tag = elem.tag.split(\"}\", 1)[1]\n return root\n\n def parse_testcases(root: ET.Element, priority: int) -> None:\n for tc in root.iter(\"testcase\"):\n name = tc.attrib.get(\"name\", \"\") or \"\"\n classname = tc.attrib.get(\"classname\", \"\") or \"\"\n key = f\"{classname}::{name}\" if classname else name\n status = \"pass\"\n if tc.find(\"failure\") is not None or tc.find(\"error\") is not None:\n status = \"fail\"\n elif tc.find(\"skipped\") is not None:\n status = \"skip\"\n update(key, status, priority)\n\n def parse_xml_text(xml_text: str, priority: int) -> bool:\n try:\n root = ET.fromstring(xml_text)\n except ET.ParseError:\n return False\n root = strip_ns(root)\n parse_testcases(root, priority)\n return True\n\n # Extract XML blocks (testsuites first, then testsuite not inside testsuites)\n suitespans: list[Tuple[int, int]] = []\n for m in re.finditer(r\"<testsuites\\b.*?</testsuites>\", log, re.DOTALL | re.IGNORECASE):\n suitespans.append(m.span())\n parse_xml_text(m.group(0), priority=2)\n\n for m in re.finditer(r\"<testsuite\\b.*?</testsuite>\", log, re.DOTALL | re.IGNORECASE):\n span = m.span()\n if any(a <= span[0] and span[1] <= b for a, b in suitespans):\n continue\n parse_xml_text(m.group(0), priority=2)\n\n # Fallback: parse individual testcase tags if XML parsing failed elsewhere\n testcase_re = re.compile(\n r\"<testcase\\b(?P<attrs>[^>]*)>(?P<body>.*?)</testcase>|<testcase\\b(?P<attrs2>[^>]*)/>\",\n re.DOTALL | re.IGNORECASE,\n )\n attr_re = re.compile(r'([\\w:.-]+)=\"(.*?)\"')\n\n for m in testcase_re.finditer(log):\n attrs = m.group(\"attrs\") or m.group(\"attrs2\") or \"\"\n body = m.group(\"body\") or \"\"\n attrs_dict = {k: v for k, v in attr_re.findall(attrs)}\n name = attrs_dict.get(\"name\", \"\")\n classname = attrs_dict.get(\"classname\", \"\")\n key = f\"{classname}::{name}\" if classname else name\n status = \"pass\"\n if re.search(r\"<(failure|error)\\b\", body, re.IGNORECASE):\n status = \"fail\"\n elif re.search(r\"<skipped\\b\", body, re.IGNORECASE):\n status = \"skip\"\n update(key, status, priority=1)\n\n # Text-based frameworks (lowest priority)\n # pytest\n for m in re.finditer(\n r\"(?m)^\\s*([^\\s:]+::[^\\s]+)\\s+(PASSED|FAILED|SKIPPED|ERROR|XFAIL|XPASS)\\b\",\n log,\n ):\n name, status_raw = m.group(1), m.group(2).upper()\n status = \"pass\"\n if status_raw in (\"FAILED\", \"ERROR\", \"XPASS\"):\n status = \"fail\"\n elif status_raw in (\"SKIPPED\", \"XFAIL\"):\n status = \"skip\"\n update(name, status, priority=0)\n\n # unittest\n for m in re.finditer(r\"(?m)^\\s*([A-Za-z0-9_.]+)\\s+\\.\\.\\.\\s+(ok|FAIL|ERROR|skipped)\\b\", log):\n name, status_raw = m.group(1), m.group(2).lower()\n status = \"pass\"\n if status_raw in (\"fail\", \"error\"):\n status = \"fail\"\n elif status_raw == \"skipped\":\n status = \"skip\"\n update(name, status, priority=0)\n\n # Go test\n for m in re.finditer(r\"(?m)^---\\s+(PASS|FAIL|SKIP):\\s+(\\S+)\", log):\n status_raw, name = m.group(1), m.group(2)\n status = \"pass\" if status_raw == \"PASS\" else \"fail\" if status_raw == \"FAIL\" else \"skip\"\n update(name, status, priority=0)\n\n # Jest-like\n for m in re.finditer(r\"(?m)^\\s*[\u2713\u2714]\\s+(.+)$\", log):\n update(m.group(1).strip(), \"pass\", priority=0)\n for m in re.finditer(r\"(?m)^\\s*[\u2715\u2716\u00d7]\\s+(.+)$\", log):\n update(m.group(1).strip(), \"fail\", priority=0)\n for m in re.finditer(r\"(?m)^\\s*[\u25cb\u25cc]\\s+(.+)$\", log):\n update(m.group(1).strip(), \"skip\", priority=0)\n\n # Flatten results\n return {k: v for k, (v, _) in results.items()}", "rebuild_cmds": []}} |
