diff --git a/android/BUILD.bazel b/android/BUILD.bazel
new file mode 100644
index 00000000000..04b60f05eed
--- /dev/null
+++ b/android/BUILD.bazel
@@ -0,0 +1,23 @@
+load("@rules_android//rules:rules.bzl", "android_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+licenses(["notice"])
+
+android_library(
+ name = "android",
+ srcs = glob([
+ "src/main/java/**/*.java",
+ ]),
+ manifest = "src/main/AndroidManifest.xml",
+ custom_package = "io.grpc.android",
+ # TODO(jdcormie): Figure out how to expose this publicly without making
+ # existing non-android users configure rules_android and maven.google.com.
+ visibility = ["//:__subpackages__"],
+ deps = [
+ "//api",
+ "//core:internal",
+ artifact("com.google.code.findbugs:jsr305"),
+ artifact("com.google.errorprone:error_prone_annotations"),
+ artifact("com.google.guava:guava"),
+ ],
+)
diff --git a/android/build.gradle b/android/build.gradle
index d0ae3b9c886..e94bf03ff37 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -14,7 +14,7 @@ android {
}
compileSdkVersion 34
defaultConfig {
- minSdkVersion 22
+ minSdkVersion 23
targetSdkVersion 33
versionCode 1
versionName "1.0"
diff --git a/android/src/main/java/io/grpc/android/UdsChannelBuilder.java b/android/src/main/java/io/grpc/android/UdsChannelBuilder.java
index 7d41301704c..6f03aa0ee5e 100644
--- a/android/src/main/java/io/grpc/android/UdsChannelBuilder.java
+++ b/android/src/main/java/io/grpc/android/UdsChannelBuilder.java
@@ -21,6 +21,7 @@
import io.grpc.ExperimentalApi;
import io.grpc.InsecureChannelCredentials;
import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.GrpcUtil;
import java.lang.reflect.InvocationTargetException;
import javax.annotation.Nullable;
import javax.net.SocketFactory;
@@ -81,7 +82,7 @@ public static ManagedChannelBuilder forPath(String path, Namespace namespace)
OKHTTP_CHANNEL_BUILDER_CLASS
.getMethod("socketFactory", SocketFactory.class)
.invoke(builder, new UdsSocketFactory(path, namespace));
- return builder;
+ return builder.proxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR);
} catch (IllegalAccessException e) {
throw new RuntimeException("Failed to create OkHttpChannelBuilder", e);
} catch (NoSuchMethodException e) {
diff --git a/api/BUILD.bazel b/api/BUILD.bazel
index 4c5e750b5e4..6de00d6272d 100644
--- a/api/BUILD.bazel
+++ b/api/BUILD.bazel
@@ -15,3 +15,21 @@ java_library(
artifact("com.google.guava:guava"),
],
)
+
+java_library(
+ name = "test_fixtures",
+ testonly = 1,
+ srcs = glob([
+ "src/testFixtures/java/io/grpc/**/*.java",
+ ]),
+ visibility = ["//xds:__pkg__"],
+ deps = [
+ "//core",
+ artifact("com.google.code.findbugs:jsr305"),
+ artifact("com.google.errorprone:error_prone_annotations"),
+ artifact("com.google.guava:guava"),
+ artifact("com.google.truth:truth"),
+ artifact("junit:junit"),
+ artifact("org.mockito:mockito-core"),
+ ],
+)
diff --git a/api/build.gradle b/api/build.gradle
index 415a17f61f8..745fa00b3f1 100644
--- a/api/build.gradle
+++ b/api/build.gradle
@@ -73,6 +73,7 @@ tasks.named("javadoc").configure {
exclude 'io/grpc/Internal?*.java'
exclude 'io/grpc/MetricRecorder.java'
exclude 'io/grpc/MetricSink.java'
+ exclude 'io/grpc/Uri.java'
}
tasks.named("sourcesJar").configure {
diff --git a/api/src/main/java/io/grpc/Channel.java b/api/src/main/java/io/grpc/Channel.java
index 60ff76ff082..e2787eb2f26 100644
--- a/api/src/main/java/io/grpc/Channel.java
+++ b/api/src/main/java/io/grpc/Channel.java
@@ -16,7 +16,6 @@
package io.grpc;
-import javax.annotation.concurrent.ThreadSafe;
/**
* A virtual connection to a conceptual endpoint, to perform RPCs. A channel is free to have zero or
@@ -29,8 +28,9 @@
* implementations using {@link ClientInterceptor}. It is expected that most application
* code will not use this class directly but rather work with stubs that have been bound to a
* Channel that was decorated during application initialization.
+ *
+ * This class is thread-safe.
*/
-@ThreadSafe
public abstract class Channel {
/**
* Create a {@link ClientCall} to the remote operation specified by the given
diff --git a/api/src/main/java/io/grpc/ChannelLogger.java b/api/src/main/java/io/grpc/ChannelLogger.java
index ce654ec9d5b..2cdf4c84724 100644
--- a/api/src/main/java/io/grpc/ChannelLogger.java
+++ b/api/src/main/java/io/grpc/ChannelLogger.java
@@ -16,15 +16,15 @@
package io.grpc;
-import javax.annotation.concurrent.ThreadSafe;
/**
* A Channel-specific logger provided by GRPC library to {@link LoadBalancer} implementations.
* Information logged here goes to Channelz, and to the Java logger of this class
* as well.
+ *
+ *
This class is thread-safe.
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5029")
-@ThreadSafe
public abstract class ChannelLogger {
/**
* Log levels. See the table below for the mapping from the ChannelLogger levels to Channelz
diff --git a/api/src/main/java/io/grpc/ClientInterceptor.java b/api/src/main/java/io/grpc/ClientInterceptor.java
index c27c31c8474..d6c8cd7e6fb 100644
--- a/api/src/main/java/io/grpc/ClientInterceptor.java
+++ b/api/src/main/java/io/grpc/ClientInterceptor.java
@@ -16,7 +16,6 @@
package io.grpc;
-import javax.annotation.concurrent.ThreadSafe;
/**
* Interface for intercepting outgoing calls before they are dispatched by a {@link Channel}.
@@ -37,8 +36,10 @@
* without completing the previous ones first. Refer to the
* {@link io.grpc.ClientCall.Listener ClientCall.Listener} docs for more details regarding thread
* safety of the returned listener.
+ *
+ *
This is thread-safe and should be considered
+ * for the errorprone ThreadSafe annotation in the future.
*/
-@ThreadSafe
public interface ClientInterceptor {
/**
* Intercept {@link ClientCall} creation by the {@code next} {@link Channel}.
diff --git a/api/src/main/java/io/grpc/ClientStreamTracer.java b/api/src/main/java/io/grpc/ClientStreamTracer.java
index 42e1fdfebea..8e11e781e7c 100644
--- a/api/src/main/java/io/grpc/ClientStreamTracer.java
+++ b/api/src/main/java/io/grpc/ClientStreamTracer.java
@@ -19,13 +19,13 @@
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.MoreObjects;
-import javax.annotation.concurrent.ThreadSafe;
/**
* {@link StreamTracer} for the client-side.
+ *
+ *
This class is thread-safe.
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
-@ThreadSafe
public abstract class ClientStreamTracer extends StreamTracer {
/**
* Indicates how long the call was delayed, in nanoseconds, due to waiting for name resolution
diff --git a/api/src/main/java/io/grpc/ConnectivityState.java b/api/src/main/java/io/grpc/ConnectivityState.java
index 677039b2517..a7407efb2e9 100644
--- a/api/src/main/java/io/grpc/ConnectivityState.java
+++ b/api/src/main/java/io/grpc/ConnectivityState.java
@@ -20,7 +20,7 @@
* The connectivity states.
*
* @see
- * more information
+ * more information
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4359")
public enum ConnectivityState {
diff --git a/api/src/main/java/io/grpc/EquivalentAddressGroup.java b/api/src/main/java/io/grpc/EquivalentAddressGroup.java
index bf8a864902c..2dd52fe7f21 100644
--- a/api/src/main/java/io/grpc/EquivalentAddressGroup.java
+++ b/api/src/main/java/io/grpc/EquivalentAddressGroup.java
@@ -55,6 +55,21 @@ public final class EquivalentAddressGroup {
*/
public static final Attributes.Key ATTR_LOCALITY_NAME =
Attributes.Key.create("io.grpc.EquivalentAddressGroup.LOCALITY");
+ /**
+ * The backend service associated with this EquivalentAddressGroup.
+ */
+ @Attr
+ static final Attributes.Key ATTR_BACKEND_SERVICE =
+ Attributes.Key.create("io.grpc.EquivalentAddressGroup.BACKEND_SERVICE");
+ /**
+ * Endpoint weight for load balancing purposes. While the type is Long, it must be a valid uint32.
+ * Must not be zero. The weight is proportional to the other endpoints; if an endpoint's weight is
+ * twice that of another endpoint, it is intended to receive twice the load.
+ */
+ @Attr
+ static final Attributes.Key ATTR_WEIGHT =
+ Attributes.Key.create("io.grpc.EquivalentAddressGroup.ATTR_WEIGHT");
+
private final List addrs;
private final Attributes attrs;
@@ -113,7 +128,9 @@ public Attributes getAttributes() {
@Override
public String toString() {
- // TODO(zpencer): Summarize return value if addr is very large
+ // EquivalentAddressGroup is intended to contain a small number of addresses for the same
+ // endpoint(e.g., IPv4/IPv6). Aggregating many groups into a single EquivalentAddressGroup
+ // is no longer done, so this no longer needs summarization.
return "[" + addrs + "/" + attrs + "]";
}
diff --git a/api/src/main/java/io/grpc/FeatureFlags.java b/api/src/main/java/io/grpc/FeatureFlags.java
new file mode 100644
index 00000000000..36fec1b9a59
--- /dev/null
+++ b/api/src/main/java/io/grpc/FeatureFlags.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+
+class FeatureFlags {
+ private static boolean enableRfc3986Uris = getFlag("GRPC_ENABLE_RFC3986_URIS", true);
+
+ /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+ @VisibleForTesting
+ static boolean setRfc3986UrisEnabled(boolean value) {
+ boolean prevValue = enableRfc3986Uris;
+ enableRfc3986Uris = value;
+ return prevValue;
+ }
+
+ /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+ static boolean getRfc3986UrisEnabled() {
+ return enableRfc3986Uris;
+ }
+
+ static boolean getFlag(String envVarName, boolean enableByDefault) {
+ String envVar = System.getenv(envVarName);
+ if (envVar == null) {
+ envVar = System.getProperty(envVarName);
+ }
+ if (envVar != null) {
+ envVar = envVar.trim();
+ }
+ if (enableByDefault) {
+ return Strings.isNullOrEmpty(envVar) || Boolean.parseBoolean(envVar);
+ } else {
+ return !Strings.isNullOrEmpty(envVar) && Boolean.parseBoolean(envVar);
+ }
+ }
+
+ private FeatureFlags() {}
+}
diff --git a/api/src/main/java/io/grpc/ForwardingServerBuilder.java b/api/src/main/java/io/grpc/ForwardingServerBuilder.java
index 9cef7cfa331..d1f183dd824 100644
--- a/api/src/main/java/io/grpc/ForwardingServerBuilder.java
+++ b/api/src/main/java/io/grpc/ForwardingServerBuilder.java
@@ -201,6 +201,12 @@ public Server build() {
return delegate().build();
}
+ @Override
+ public T addMetricSink(MetricSink metricSink) {
+ delegate().addMetricSink(metricSink);
+ return thisT();
+ }
+
@Override
public String toString() {
return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
diff --git a/api/src/main/java/io/grpc/Grpc.java b/api/src/main/java/io/grpc/Grpc.java
index baa9f5f0ab6..628f6fac399 100644
--- a/api/src/main/java/io/grpc/Grpc.java
+++ b/api/src/main/java/io/grpc/Grpc.java
@@ -56,6 +56,13 @@ private Grpc() {
public static final Attributes.Key TRANSPORT_ATTR_SSL_SESSION =
Attributes.Key.create("io.grpc.Grpc.TRANSPORT_ATTR_SSL_SESSION");
+ /**
+ * The value for the custom label of per-RPC metrics. Defaults to empty string when unset. Must
+ * not be set to {@code null}.
+ */
+ public static final CallOptions.Key CALL_OPTION_CUSTOM_LABEL =
+ CallOptions.Key.createWithDefault("io.grpc.Grpc.CALL_OPTION_CUSTOM_LABEL", "");
+
/**
* Annotation for transport attributes. It follows the annotation semantics defined
* by {@link Attributes}.
@@ -66,11 +73,10 @@ private Grpc() {
public @interface TransportAttr {}
/**
- * Creates a channel builder with a target string and credentials. The target can be either a
- * valid {@link NameResolver}-compliant URI, or an authority string.
+ * Creates a channel builder with a target string and credentials. The target can be either an RFC
+ * 3986 URI, or an authority string.
*
- * A {@code NameResolver}-compliant URI is an absolute hierarchical URI as defined by {@link
- * java.net.URI}. Example URIs:
+ *
Example URIs:
*
* - {@code "dns:///foo.googleapis.com:8080"}
* - {@code "dns:///foo.googleapis.com"}
@@ -78,13 +84,13 @@ private Grpc() {
* - {@code "dns://8.8.8.8/foo.googleapis.com:8080"}
* - {@code "dns://8.8.8.8/foo.googleapis.com"}
* - {@code "zookeeper://zk.example.com:9900/example_service"}
+ * - {@code "intent:#Intent;package=com.some.app;action=a;category=c;end;"}
*
*
- * An authority string will be converted to a {@code NameResolver}-compliant URI, which has
- * the scheme from the name resolver with the highest priority (e.g. {@code "dns"}),
- * no authority, and the original authority string as its path after properly escaped.
- * We recommend libraries to specify the schema explicitly if it is known, since libraries cannot
- * know which NameResolver will be default during runtime.
+ *
An authority string will be converted to a URI having the scheme of the name resolver with
+ * the highest priority (e.g. {@code "dns"}), the empty string as the authority, and
+ * {@code target} as its absolute path. We recommend libraries specify {@code target} as a URI
+ * instead since they cannot know which NameResolver will be default at runtime.
* Example authority strings:
*
* - {@code "localhost"}
@@ -95,12 +101,46 @@ private Grpc() {
* - {@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]"}
* - {@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"}
*
+ *
+ * The URI form of {@code target} is preferred because it is less ambiguous. For example, the
+ * target string {@code foo:8080} is a valid authority string with host {@code foo} and port
+ * {@code 8080} but it is also a valid RFC 3986 URI with scheme {@code foo} and path {@code 8080}.
+ * gRPC prioritizes the URI form, which means {@code foo:8080} will be treated as a URI with
+ * scheme {@code foo}. Using {@code dns:///foo:8080} avoids this ambiguity.
*/
public static ManagedChannelBuilder newChannelBuilder(
String target, ChannelCredentials creds) {
return ManagedChannelRegistry.getDefaultRegistry().newChannelBuilder(target, creds);
}
+ /**
+ * Creates a channel builder with a target string, credentials, and a specific
+ * name resolver registry.
+ *
+ *
The provided {@code nameResolverRegistry} is used to resolve the target address
+ * into physical addresses (e.g., DNS or custom schemes).
+ *
+ * @param target the target URI for the channel, such as {@code "localhost:8080"}
+ * or {@code "dns:///example.com"}
+ * @param creds the channel credentials to use for secure communication
+ * @param nameResolverRegistry the registry used to look up {@link NameResolver}
+ * providers for the target
+ * @return a {@link ManagedChannelBuilder} instance configured with the given parameters
+ * @throws IllegalArgumentException if no provider is available for the given target
+ * or credentials
+ * @since 1.83.0
+ */
+ @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12694")
+ public static ManagedChannelBuilder newChannelBuilder(
+ String target,
+ ChannelCredentials creds,
+ NameResolverRegistry nameResolverRegistry) {
+ return ManagedChannelRegistry.getDefaultRegistry().newChannelBuilder(
+ nameResolverRegistry,
+ target,
+ creds);
+ }
+
/**
* Creates a channel builder from a host, port, and credentials. The host and port are combined to
* form an authority string and then passed to {@link #newChannelBuilder(String,
diff --git a/api/src/main/java/io/grpc/HandlerRegistry.java b/api/src/main/java/io/grpc/HandlerRegistry.java
index 4aaf0114fb1..148573ada9a 100644
--- a/api/src/main/java/io/grpc/HandlerRegistry.java
+++ b/api/src/main/java/io/grpc/HandlerRegistry.java
@@ -19,12 +19,12 @@
import java.util.Collections;
import java.util.List;
import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
/**
* Registry of services and their methods used by servers to dispatching incoming calls.
+ *
+ *
This class is thread-safe.
*/
-@ThreadSafe
public abstract class HandlerRegistry {
/**
diff --git a/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java b/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java
index d59c53db1d1..0df8dc452c1 100644
--- a/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java
+++ b/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java
@@ -23,6 +23,9 @@
import com.google.common.base.Objects;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
import javax.annotation.Nullable;
/**
@@ -33,6 +36,8 @@ public final class HttpConnectProxiedSocketAddress extends ProxiedSocketAddress
private final SocketAddress proxyAddress;
private final InetSocketAddress targetAddress;
+ @SuppressWarnings("serial")
+ private final Map headers;
@Nullable
private final String username;
@Nullable
@@ -41,6 +46,7 @@ public final class HttpConnectProxiedSocketAddress extends ProxiedSocketAddress
private HttpConnectProxiedSocketAddress(
SocketAddress proxyAddress,
InetSocketAddress targetAddress,
+ Map headers,
@Nullable String username,
@Nullable String password) {
checkNotNull(proxyAddress, "proxyAddress");
@@ -53,6 +59,7 @@ private HttpConnectProxiedSocketAddress(
}
this.proxyAddress = proxyAddress;
this.targetAddress = targetAddress;
+ this.headers = headers;
this.username = username;
this.password = password;
}
@@ -87,6 +94,14 @@ public InetSocketAddress getTargetAddress() {
return targetAddress;
}
+ /**
+ * Returns the custom HTTP headers to be sent during the HTTP CONNECT handshake.
+ */
+ @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12479")
+ public Map getHeaders() {
+ return headers;
+ }
+
@Override
public boolean equals(Object o) {
if (!(o instanceof HttpConnectProxiedSocketAddress)) {
@@ -95,13 +110,14 @@ public boolean equals(Object o) {
HttpConnectProxiedSocketAddress that = (HttpConnectProxiedSocketAddress) o;
return Objects.equal(proxyAddress, that.proxyAddress)
&& Objects.equal(targetAddress, that.targetAddress)
+ && Objects.equal(headers, that.headers)
&& Objects.equal(username, that.username)
&& Objects.equal(password, that.password);
}
@Override
public int hashCode() {
- return Objects.hashCode(proxyAddress, targetAddress, username, password);
+ return Objects.hashCode(proxyAddress, targetAddress, username, password, headers);
}
@Override
@@ -109,6 +125,7 @@ public String toString() {
return MoreObjects.toStringHelper(this)
.add("proxyAddr", proxyAddress)
.add("targetAddr", targetAddress)
+ .add("headers", headers)
.add("username", username)
// Intentionally mask out password
.add("hasPassword", password != null)
@@ -129,6 +146,7 @@ public static final class Builder {
private SocketAddress proxyAddress;
private InetSocketAddress targetAddress;
+ private Map headers = Collections.emptyMap();
@Nullable
private String username;
@Nullable
@@ -153,6 +171,18 @@ public Builder setTargetAddress(InetSocketAddress targetAddress) {
return this;
}
+ /**
+ * Sets custom HTTP headers to be sent during the HTTP CONNECT handshake. This is an optional
+ * field. The headers will be sent in addition to any authentication headers (if username and
+ * password are set).
+ */
+ @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12479")
+ public Builder setHeaders(Map headers) {
+ this.headers = Collections.unmodifiableMap(
+ new HashMap<>(checkNotNull(headers, "headers")));
+ return this;
+ }
+
/**
* Sets the username used to connect to the proxy. This is an optional field and can be {@code
* null}.
@@ -175,7 +205,8 @@ public Builder setPassword(@Nullable String password) {
* Creates an {@code HttpConnectProxiedSocketAddress}.
*/
public HttpConnectProxiedSocketAddress build() {
- return new HttpConnectProxiedSocketAddress(proxyAddress, targetAddress, username, password);
+ return new HttpConnectProxiedSocketAddress(
+ proxyAddress, targetAddress, headers, username, password);
}
}
}
diff --git a/api/src/main/java/io/grpc/InternalEquivalentAddressGroup.java b/api/src/main/java/io/grpc/InternalEquivalentAddressGroup.java
new file mode 100644
index 00000000000..cd171208af7
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalEquivalentAddressGroup.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+@Internal
+public final class InternalEquivalentAddressGroup {
+ private InternalEquivalentAddressGroup() {}
+
+ /**
+ * Endpoint weight for load balancing purposes. While the type is Long, it must be a valid uint32.
+ * Must not be zero. The weight is proportional to the other endpoints; if an endpoint's weight is
+ * twice that of another endpoint, it is intended to receive twice the load.
+ */
+ public static final Attributes.Key ATTR_WEIGHT = EquivalentAddressGroup.ATTR_WEIGHT;
+
+ /**
+ * The backend service associated with this EquivalentAddressGroup.
+ */
+ public static final Attributes.Key ATTR_BACKEND_SERVICE =
+ EquivalentAddressGroup.ATTR_BACKEND_SERVICE;
+}
diff --git a/api/src/main/java/io/grpc/InternalFeatureFlags.java b/api/src/main/java/io/grpc/InternalFeatureFlags.java
new file mode 100644
index 00000000000..a1e771a7571
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalFeatureFlags.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import com.google.common.annotations.VisibleForTesting;
+
+/** Global variables that govern major changes to the behavior of more than one grpc module. */
+@Internal
+public class InternalFeatureFlags {
+
+ /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+ @VisibleForTesting
+ public static boolean setRfc3986UrisEnabled(boolean value) {
+ return FeatureFlags.setRfc3986UrisEnabled(value);
+ }
+
+ /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+ public static boolean getRfc3986UrisEnabled() {
+ return FeatureFlags.getRfc3986UrisEnabled();
+ }
+
+ public static boolean getFlag(String envVarName, boolean enableByDefault) {
+ return FeatureFlags.getFlag(envVarName, enableByDefault);
+ }
+
+ private InternalFeatureFlags() {}
+}
diff --git a/api/src/main/java/io/grpc/InternalServiceProviders.java b/api/src/main/java/io/grpc/InternalServiceProviders.java
index c72e01db67a..debc786a82a 100644
--- a/api/src/main/java/io/grpc/InternalServiceProviders.java
+++ b/api/src/main/java/io/grpc/InternalServiceProviders.java
@@ -17,7 +17,9 @@
package io.grpc;
import com.google.common.annotations.VisibleForTesting;
+import java.util.Iterator;
import java.util.List;
+import java.util.ServiceLoader;
@Internal
public final class InternalServiceProviders {
@@ -27,12 +29,17 @@ private InternalServiceProviders() {
/**
* Accessor for method.
*/
- public static T load(
+ @Deprecated
+ public static List loadAll(
Class klass,
- Iterable> hardcoded,
+ Iterable> hardCodedClasses,
ClassLoader classLoader,
PriorityAccessor priorityAccessor) {
- return ServiceProviders.load(klass, hardcoded, classLoader, priorityAccessor);
+ return loadAll(
+ klass,
+ ServiceLoader.load(klass, classLoader).iterator(),
+ () -> hardCodedClasses,
+ priorityAccessor);
}
/**
@@ -40,10 +47,10 @@ public static T load(
*/
public static List loadAll(
Class klass,
- Iterable> hardCodedClasses,
- ClassLoader classLoader,
+ Iterator serviceLoader,
+ Supplier>> hardCodedClasses,
PriorityAccessor priorityAccessor) {
- return ServiceProviders.loadAll(klass, hardCodedClasses, classLoader, priorityAccessor);
+ return ServiceProviders.loadAll(klass, serviceLoader, hardCodedClasses::get, priorityAccessor);
}
/**
@@ -71,4 +78,8 @@ public static boolean isAndroid(ClassLoader cl) {
}
public interface PriorityAccessor extends ServiceProviders.PriorityAccessor {}
+
+ public interface Supplier {
+ T get();
+ }
}
diff --git a/api/src/main/java/io/grpc/InternalTcpMetrics.java b/api/src/main/java/io/grpc/InternalTcpMetrics.java
new file mode 100644
index 00000000000..3dd89b6f76c
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalTcpMetrics.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * TCP Metrics defined to be shared across transport implementations.
+ * These metrics and their definitions are specified in
+ * gRFC
+ * A80.
+ */
+@Internal
+public final class InternalTcpMetrics {
+
+ private InternalTcpMetrics() {
+ }
+
+ private static final List OPTIONAL_LABELS = Arrays.asList(
+ "network.local.address",
+ "network.local.port",
+ "network.peer.address",
+ "network.peer.port");
+
+ public static final DoubleHistogramMetricInstrument MIN_RTT_INSTRUMENT =
+ MetricInstrumentRegistry.getDefaultRegistry()
+ .registerDoubleHistogram(
+ "grpc.tcp.min_rtt",
+ "Minimum round-trip time of a TCP connection",
+ "s",
+ Collections.emptyList(),
+ Collections.emptyList(),
+ OPTIONAL_LABELS,
+ false);
+
+ public static final LongCounterMetricInstrument CONNECTIONS_CREATED_INSTRUMENT =
+ MetricInstrumentRegistry
+ .getDefaultRegistry()
+ .registerLongCounter(
+ "grpc.tcp.connections_created",
+ "The total number of TCP connections established.",
+ "{connection}",
+ Collections.emptyList(),
+ OPTIONAL_LABELS,
+ false);
+
+ public static final LongUpDownCounterMetricInstrument CONNECTION_COUNT_INSTRUMENT =
+ MetricInstrumentRegistry
+ .getDefaultRegistry()
+ .registerLongUpDownCounter(
+ "grpc.tcp.connection_count",
+ "The current number of active TCP connections.",
+ "{connection}",
+ Collections.emptyList(),
+ OPTIONAL_LABELS,
+ false);
+
+ public static final LongCounterMetricInstrument PACKETS_RETRANSMITTED_INSTRUMENT =
+ MetricInstrumentRegistry
+ .getDefaultRegistry()
+ .registerLongCounter(
+ "grpc.tcp.packets_retransmitted",
+ "The total number of packets retransmitted for all TCP connections.",
+ "{packet}",
+ Collections.emptyList(),
+ OPTIONAL_LABELS,
+ false);
+
+ public static final LongCounterMetricInstrument RECURRING_RETRANSMITS_INSTRUMENT =
+ MetricInstrumentRegistry
+ .getDefaultRegistry()
+ .registerLongCounter(
+ "grpc.tcp.recurring_retransmits",
+ "The total number of times the retransmit timer "
+ + "popped for all TCP connections.",
+ "{timeout}",
+ Collections.emptyList(),
+ OPTIONAL_LABELS,
+ false);
+
+}
diff --git a/api/src/main/java/io/grpc/LoadBalancer.java b/api/src/main/java/io/grpc/LoadBalancer.java
index adc43b19841..5dd44a492ee 100644
--- a/api/src/main/java/io/grpc/LoadBalancer.java
+++ b/api/src/main/java/io/grpc/LoadBalancer.java
@@ -32,7 +32,6 @@
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import javax.annotation.concurrent.NotThreadSafe;
-import javax.annotation.concurrent.ThreadSafe;
/**
* A pluggable component that receives resolved addresses from {@link NameResolver} and provides the
@@ -64,7 +63,7 @@
* allows implementations to schedule tasks to be run in the same Synchronization Context, with or
* without a delay, thus those tasks don't need to worry about synchronizing with the balancer
* methods.
- *
+ *
* However, the actual running thread may be the network thread, thus the following rules must be
* followed to prevent blocking or even dead-locking in a network:
*
@@ -156,15 +155,16 @@ public String toString() {
private int recursionCount;
/**
- * Handles newly resolved server groups and metadata attributes from name resolution system.
- * {@code servers} contained in {@link EquivalentAddressGroup} should be considered equivalent
- * but may be flattened into a single list if needed.
- *
- *
Implementations should not modify the given {@code servers}.
+ * Handles newly resolved addresses and metadata attributes from name resolution system.
+ * Addresses in {@link EquivalentAddressGroup} should be considered equivalent but may be
+ * flattened into a single list if needed.
*
* @param resolvedAddresses the resolved server addresses, attributes, and config.
* @since 1.21.0
+ *
+ * @deprecated Use instead {@link #acceptResolvedAddresses(ResolvedAddresses)}
*/
+ @Deprecated
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
if (recursionCount++ == 0) {
// Note that the information about the addresses actually being accepted will be lost
@@ -179,12 +179,10 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
* EquivalentAddressGroup} addresses should be considered equivalent but may be flattened into a
* single list if needed.
*
- *
Implementations can choose to reject the given addresses by returning {@code false}.
- *
- *
Implementations should not modify the given {@code addresses}.
+ * @param resolvedAddresses the resolved server addresses, attributes, and config
+ * @return {@code Status.OK} if the resolved addresses were accepted, otherwise an error to report
+ * to the name resolver
*
- * @param resolvedAddresses the resolved server addresses, attributes, and config.
- * @return {@code true} if the resolved addresses were accepted. {@code false} if rejected.
* @since 1.49.0
*/
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
@@ -339,8 +337,8 @@ public ResolvedAddresses build() {
public String toString() {
return MoreObjects.toStringHelper(this)
.add("addresses", addresses)
- .add("attributes", attributes)
.add("loadBalancingPolicyConfig", loadBalancingPolicyConfig)
+ .add("attributes", attributes)
.toString();
}
@@ -418,7 +416,16 @@ public void handleSubchannelState(
*
*
This method should always return a constant value. It's not specified when this will be
* called.
+ *
+ *
Note that this method is only called when implementing {@code handleResolvedAddresses()}
+ * instead of {@code acceptResolvedAddresses()}.
+ *
+ * @deprecated Instead of overwriting this and {@code handleResolvedAddresses()}, only
+ * overwrite {@code acceptResolvedAddresses()} which indicates if the addresses provided
+ * by the name resolver are acceptable with the {@code boolean} return value.
*/
+ @Deprecated
+ @SuppressWarnings("InlineMeSuggester")
public boolean canHandleEmptyAddressListFromNameResolution() {
return false;
}
@@ -442,7 +449,6 @@ public void requestConnection() {}
*
* @since 1.2.0
*/
- @ThreadSafe
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
public abstract static class SubchannelPicker {
/**
@@ -632,6 +638,8 @@ private PickResult(
* stream is created at all in some cases.
* @since 1.3.0
*/
+ // TODO(shivaspeaks): Need to deprecate old APIs and create new ones,
+ // per https://github.com/grpc/grpc-java/issues/12662.
public static PickResult withSubchannel(
Subchannel subchannel, @Nullable ClientStreamTracer.Factory streamTracerFactory) {
return new PickResult(
@@ -661,6 +669,28 @@ public static PickResult withSubchannel(Subchannel subchannel) {
return withSubchannel(subchannel, null);
}
+ /**
+ * Creates a new {@code PickResult} with the given {@code subchannel},
+ * but retains all other properties from this {@code PickResult}.
+ *
+ * @since 1.80.0
+ */
+ public PickResult copyWithSubchannel(Subchannel subchannel) {
+ return new PickResult(checkNotNull(subchannel, "subchannel"), streamTracerFactory,
+ status, drop, authorityOverride);
+ }
+
+ /**
+ * Creates a new {@code PickResult} with the given {@code streamTracerFactory},
+ * but retains all other properties from this {@code PickResult}.
+ *
+ * @since 1.80.0
+ */
+ public PickResult copyWithStreamTracerFactory(
+ @Nullable ClientStreamTracer.Factory streamTracerFactory) {
+ return new PickResult(subchannel, streamTracerFactory, status, drop, authorityOverride);
+ }
+
/**
* A decision to report a connectivity error to the RPC. If the RPC is {@link
* CallOptions#withWaitForReady wait-for-ready}, it will stay buffered. Otherwise, it will fail
@@ -998,9 +1028,10 @@ public String toString() {
/**
* Provides essentials for LoadBalancer implementations.
*
+ *
This class is thread-safe.
+ *
* @since 1.2.0
*/
- @ThreadSafe
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
public abstract static class Helper {
/**
@@ -1300,7 +1331,7 @@ public MetricRecorder getMetricRecorder() {
}
/**
- * A logical connection to a server, or a group of equivalent servers represented by an {@link
+ * A logical connection to a server, or a group of equivalent servers represented by an {@link
* EquivalentAddressGroup}.
*
*
It maintains at most one physical connection (aka transport) for sending new RPCs, while
@@ -1519,9 +1550,10 @@ public interface SubchannelStateListener {
/**
* Factory to create {@link LoadBalancer} instance.
*
+ *
This class is thread-safe.
+ *
* @since 1.2.0
*/
- @ThreadSafe
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
public abstract static class Factory {
/**
diff --git a/api/src/main/java/io/grpc/LoadBalancerProvider.java b/api/src/main/java/io/grpc/LoadBalancerProvider.java
index bb4c574211e..7dc30d6baaf 100644
--- a/api/src/main/java/io/grpc/LoadBalancerProvider.java
+++ b/api/src/main/java/io/grpc/LoadBalancerProvider.java
@@ -81,7 +81,7 @@ public abstract class LoadBalancerProvider extends LoadBalancer.Factory {
* @return a tuple of the fully parsed and validated balancer configuration, else the Status.
* @since 1.20.0
* @see
- * A24-lb-policy-config.md
+ * A24-lb-policy-config.md
*/
public ConfigOrError parseLoadBalancingPolicyConfig(Map rawLoadBalancingPolicyConfig) {
return UNKNOWN_CONFIG;
diff --git a/api/src/main/java/io/grpc/LoadBalancerRegistry.java b/api/src/main/java/io/grpc/LoadBalancerRegistry.java
index f6b69f978b8..a8fbc102f5f 100644
--- a/api/src/main/java/io/grpc/LoadBalancerRegistry.java
+++ b/api/src/main/java/io/grpc/LoadBalancerRegistry.java
@@ -26,6 +26,7 @@
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
+import java.util.ServiceLoader;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
@@ -42,7 +43,6 @@
public final class LoadBalancerRegistry {
private static final Logger logger = Logger.getLogger(LoadBalancerRegistry.class.getName());
private static LoadBalancerRegistry instance;
- private static final Iterable> HARDCODED_CLASSES = getHardCodedClasses();
private final LinkedHashSet allProviders =
new LinkedHashSet<>();
@@ -101,8 +101,10 @@ public static synchronized LoadBalancerRegistry getDefaultRegistry() {
if (instance == null) {
List providerList = ServiceProviders.loadAll(
LoadBalancerProvider.class,
- HARDCODED_CLASSES,
- LoadBalancerProvider.class.getClassLoader(),
+ ServiceLoader
+ .load(LoadBalancerProvider.class, LoadBalancerProvider.class.getClassLoader())
+ .iterator(),
+ LoadBalancerRegistry::getHardCodedClasses,
new LoadBalancerPriorityAccessor());
instance = new LoadBalancerRegistry();
for (LoadBalancerProvider provider : providerList) {
diff --git a/api/src/main/java/io/grpc/ManagedChannel.java b/api/src/main/java/io/grpc/ManagedChannel.java
index 7875fdb57f2..2b1d89946bf 100644
--- a/api/src/main/java/io/grpc/ManagedChannel.java
+++ b/api/src/main/java/io/grpc/ManagedChannel.java
@@ -17,12 +17,12 @@
package io.grpc;
import java.util.concurrent.TimeUnit;
-import javax.annotation.concurrent.ThreadSafe;
/**
* A {@link Channel} that provides lifecycle management.
+ *
+ * This class is thread-safe.
*/
-@ThreadSafe
public abstract class ManagedChannel extends Channel {
/**
* Initiates an orderly shutdown in which preexisting calls continue but new calls are immediately
diff --git a/api/src/main/java/io/grpc/ManagedChannelBuilder.java b/api/src/main/java/io/grpc/ManagedChannelBuilder.java
index df867d09ba1..7681c8f7b62 100644
--- a/api/src/main/java/io/grpc/ManagedChannelBuilder.java
+++ b/api/src/main/java/io/grpc/ManagedChannelBuilder.java
@@ -45,11 +45,10 @@ public static ManagedChannelBuilder forAddress(String name, int port) {
}
/**
- * Creates a channel with a target string, which can be either a valid {@link
- * NameResolver}-compliant URI, or an authority string.
+ * Creates a channel with a target string, which can be either an RFC 3986 URI, or an authority
+ * string.
*
- *
A {@code NameResolver}-compliant URI is an absolute hierarchical URI as defined by {@link
- * java.net.URI}. Example URIs:
+ *
Example URIs:
*
* - {@code "dns:///foo.googleapis.com:8080"}
* - {@code "dns:///foo.googleapis.com"}
@@ -57,13 +56,13 @@ public static ManagedChannelBuilder forAddress(String name, int port) {
* - {@code "dns://8.8.8.8/foo.googleapis.com:8080"}
* - {@code "dns://8.8.8.8/foo.googleapis.com"}
* - {@code "zookeeper://zk.example.com:9900/example_service"}
+ * - {@code "intent:#Intent;package=com.some.app;action=a;category=c;end;"}
*
*
- * An authority string will be converted to a {@code NameResolver}-compliant URI, which has
- * the scheme from the name resolver with the highest priority (e.g. {@code "dns"}),
- * no authority, and the original authority string as its path after properly escaped.
- * We recommend libraries to specify the schema explicitly if it is known, since libraries cannot
- * know which NameResolver will be default during runtime.
+ *
An authority string will be converted to a URI having the scheme of the name resolver with
+ * the highest priority (e.g. {@code "dns"}), the empty string as the authority, and
+ * {@code target} as its absolute path. We recommend libraries specify {@code target} as a URI
+ * instead since they cannot know which NameResolver will be default at runtime.
* Example authority strings:
*
* - {@code "localhost"}
@@ -75,6 +74,12 @@ public static ManagedChannelBuilder forAddress(String name, int port) {
* - {@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"}
*
*
+ * The URI form of {@code target} is preferred because it is less ambiguous. For example, the
+ * target string {@code foo:8080} is a valid authority string with host {@code foo} and port
+ * {@code 8080} but it is also a valid RFC 3986 URI with scheme {@code foo} and path {@code 8080}.
+ * gRPC prioritizes the URI form, which means {@code foo:8080} will be treated as a URI with
+ * scheme {@code foo}. Using {@code dns:///foo:8080} avoids this ambiguity.
+ *
*
Note that there is an open JDK bug on {@link java.net.URI} class parsing an ipv6 scope ID:
* bugs.openjdk.org/browse/JDK-8199396. This method is exposed to this bug. If you experience an
* issue, a work-around is to convert the scope ID to its numeric form (e.g. by using
@@ -374,9 +379,17 @@ public T maxInboundMetadataSize(int bytes) {
* notice when they are causing excessive load. Clients are strongly encouraged to use only as
* small of a value as necessary.
*
+ *
When the channel implementation supports TCP_USER_TIMEOUT, enabling keepalive will also
+ * enable TCP_USER_TIMEOUT for the connection. This requires all sent packets to receive
+ * a TCP acknowledgement before the keepalive timeout. The keepalive time is not used for
+ * TCP_USER_TIMEOUT, except as a signal to enable the feature. grpc-netty supports
+ * TCP_USER_TIMEOUT on Linux platforms supported by netty-transport-native-epoll.
+ *
* @throws UnsupportedOperationException if unsupported
* @see gRFC A8
* Client-side Keepalive
+ * @see gRFC A18
+ * TCP User Timeout
* @since 1.7.0
*/
public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
@@ -393,6 +406,8 @@ public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
* @throws UnsupportedOperationException if unsupported
* @see gRFC A8
* Client-side Keepalive
+ * @see gRFC A18
+ * TCP User Timeout
* @since 1.7.0
*/
public T keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
diff --git a/api/src/main/java/io/grpc/ManagedChannelProvider.java b/api/src/main/java/io/grpc/ManagedChannelProvider.java
index 42941dfc809..8a61c097ed8 100644
--- a/api/src/main/java/io/grpc/ManagedChannelProvider.java
+++ b/api/src/main/java/io/grpc/ManagedChannelProvider.java
@@ -81,6 +81,31 @@ protected NewChannelBuilderResult newChannelBuilder(String target, ChannelCreden
return NewChannelBuilderResult.error("ChannelCredentials are unsupported");
}
+ /**
+ * Creates a channel builder using the provided target, credentials, and resolution
+ * components.
+ *
+ *
This method allows for fine-grained control over name resolution by providing
+ * both a {@link NameResolverRegistry} and a specific {@link NameResolverProvider}.
+ * This returns a {@link NewChannelBuilderResult},
+ * which may contain an error string if the provided credentials or target are
+ * not supported by this provider.
+ *
+ * @param target the target URI for the channel
+ * @param creds the channel credentials to use
+ * @param nameResolverRegistry the registry used for looking up name resolvers
+ * @param nameResolverProvider a specific provider to use, or {@code null} to
+ * search the registry
+ * @return a {@link NewChannelBuilderResult} containing either the builder or an
+ * error description
+ * @since 1.83.0
+ */
+ protected NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds,
+ NameResolverRegistry nameResolverRegistry,
+ NameResolverProvider nameResolverProvider) {
+ return newChannelBuilder(target, creds);
+ }
+
/**
* Returns the {@link SocketAddress} types this ManagedChannelProvider supports.
*/
diff --git a/api/src/main/java/io/grpc/ManagedChannelRegistry.java b/api/src/main/java/io/grpc/ManagedChannelRegistry.java
index aed5eca9abf..c70b6812651 100644
--- a/api/src/main/java/io/grpc/ManagedChannelRegistry.java
+++ b/api/src/main/java/io/grpc/ManagedChannelRegistry.java
@@ -29,6 +29,7 @@
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
+import java.util.ServiceLoader;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.concurrent.ThreadSafe;
@@ -100,8 +101,10 @@ public static synchronized ManagedChannelRegistry getDefaultRegistry() {
if (instance == null) {
List providerList = ServiceProviders.loadAll(
ManagedChannelProvider.class,
- getHardCodedClasses(),
- ManagedChannelProvider.class.getClassLoader(),
+ ServiceLoader
+ .load(ManagedChannelProvider.class, ManagedChannelProvider.class.getClassLoader())
+ .iterator(),
+ ManagedChannelRegistry::getHardCodedClasses,
new ManagedChannelPriorityAccessor());
instance = new ManagedChannelRegistry();
for (ManagedChannelProvider provider : providerList) {
@@ -155,13 +158,15 @@ ManagedChannelBuilder newChannelBuilder(String target, ChannelCredentials cre
return newChannelBuilder(NameResolverRegistry.getDefaultRegistry(), target, creds);
}
- @VisibleForTesting
ManagedChannelBuilder newChannelBuilder(NameResolverRegistry nameResolverRegistry,
String target, ChannelCredentials creds) {
NameResolverProvider nameResolverProvider = null;
try {
- URI uri = new URI(target);
- nameResolverProvider = nameResolverRegistry.getProviderForScheme(uri.getScheme());
+ String scheme =
+ FeatureFlags.getRfc3986UrisEnabled()
+ ? Uri.parse(target).getScheme()
+ : new URI(target).getScheme();
+ nameResolverProvider = nameResolverRegistry.getProviderForScheme(scheme);
} catch (URISyntaxException ignore) {
// bad URI found, just ignore and continue
}
@@ -192,7 +197,7 @@ ManagedChannelBuilder newChannelBuilder(NameResolverRegistry nameResolverRegi
continue;
}
ManagedChannelProvider.NewChannelBuilderResult result
- = provider.newChannelBuilder(target, creds);
+ = provider.newChannelBuilder(target, creds, nameResolverRegistry, nameResolverProvider);
if (result.getChannelBuilder() != null) {
return result.getChannelBuilder();
}
diff --git a/api/src/main/java/io/grpc/NameResolver.java b/api/src/main/java/io/grpc/NameResolver.java
index 2ac4ecae69e..f52a38ba809 100644
--- a/api/src/main/java/io/grpc/NameResolver.java
+++ b/api/src/main/java/io/grpc/NameResolver.java
@@ -35,7 +35,6 @@
import java.util.concurrent.ScheduledExecutorService;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
-import javax.annotation.concurrent.ThreadSafe;
/**
* A pluggable component that resolves a target {@link URI} and return addresses to the caller.
@@ -78,7 +77,7 @@ public abstract class NameResolver {
* Starts the resolution. The method is not supposed to throw any exceptions. That might cause the
* Channel that the name resolver is serving to crash. Errors should be propagated
* through {@link Listener#onError}.
- *
+ *
* An instance may not be started more than once, by any overload of this method, even after
* an intervening call to {@link #shutdown}.
*
@@ -97,8 +96,14 @@ public void onError(Status error) {
@Override
public void onResult(ResolutionResult resolutionResult) {
- listener.onAddresses(resolutionResult.getAddressesOrError().getValue(),
- resolutionResult.getAttributes());
+ StatusOr> addressesOrError =
+ resolutionResult.getAddressesOrError();
+ if (addressesOrError.hasValue()) {
+ listener.onAddresses(addressesOrError.getValue(),
+ resolutionResult.getAttributes());
+ } else {
+ listener.onError(addressesOrError.getStatus());
+ }
}
});
}
@@ -108,7 +113,7 @@ public void onResult(ResolutionResult resolutionResult) {
* Starts the resolution. The method is not supposed to throw any exceptions. That might cause the
* Channel that the name resolver is serving to crash. Errors should be propagated
* through {@link Listener2#onError}.
- *
+ *
* An instance may not be started more than once, by any overload of this method, even after
* an intervening call to {@link #shutdown}.
*
@@ -152,6 +157,10 @@ public abstract static class Factory {
* cannot be resolved by this factory. The decision should be solely based on the scheme of the
* URI.
*
+ *
This method will eventually be deprecated and removed as part of a migration from {@code
+ * java.net.URI} to {@code io.grpc.Uri}. Implementations will override {@link
+ * #newNameResolver(Uri, Args)} instead.
+ *
* @param targetUri the target URI to be resolved, whose scheme must not be {@code null}
* @param args other information that may be useful
*
@@ -159,6 +168,37 @@ public abstract static class Factory {
*/
public abstract NameResolver newNameResolver(URI targetUri, final Args args);
+ /**
+ * Creates a {@link NameResolver} for the given target URI.
+ *
+ *
Implementations return {@code null} if 'targetUri' cannot be resolved by this factory. The
+ * decision should be solely based on the target's scheme.
+ *
+ *
All {@link NameResolver.Factory} implementations should override this method, as it will
+ * eventually replace {@link #newNameResolver(URI, Args)}. For backwards compatibility, this
+ * default implementation delegates to {@link #newNameResolver(URI, Args)} if 'targetUri' can be
+ * converted to a java.net.URI.
+ *
+ *
NB: Conversion is not always possible, for example {@code scheme:#frag} is a valid {@link
+ * Uri} but not a valid {@link URI} because its path is empty. The default implementation throws
+ * IllegalArgumentException in these cases.
+ *
+ * @param targetUri the target URI to be resolved
+ * @param args other information that may be useful
+ * @throws IllegalArgumentException if targetUri does not have the expected form
+ * @since 1.79
+ */
+ public NameResolver newNameResolver(Uri targetUri, final Args args) {
+ // Not every io.grpc.Uri can be converted but in the ordinary ManagedChannel creation flow,
+ // any IllegalArgumentException thrown here would have happened anyway, just earlier. That's
+ // because parse/toString is transparent so java.net.URI#create here sees the original target
+ // string just like it did before the io.grpc.Uri migration.
+ //
+ // Throwing IAE shouldn't surprise non-framework callers either. After all, many existing
+ // Factory impls are picky about targetUri and throw IAE when it doesn't look how they expect.
+ return newNameResolver(URI.create(targetUri.toString()), args);
+ }
+
/**
* Returns the default scheme, which will be used to construct a URI when {@link
* ManagedChannelBuilder#forTarget(String)} is given an authority string instead of a compliant
@@ -174,10 +214,11 @@ public abstract static class Factory {
*
*
All methods are expected to return quickly.
*
+ *
This interface is thread-safe.
+ *
* @since 1.0.0
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
- @ThreadSafe
public interface Listener {
/**
* Handles updates on resolved addresses and attributes.
@@ -314,7 +355,7 @@ public static final class Args {
@Nullable private final ChannelLogger channelLogger;
@Nullable private final Executor executor;
@Nullable private final String overrideAuthority;
- @Nullable private final MetricRecorder metricRecorder;
+ private final MetricRecorder metricRecorder;
@Nullable private final NameResolverRegistry nameResolverRegistry;
@Nullable private final IdentityHashMap, Object> customArgs;
@@ -328,7 +369,8 @@ private Args(Builder builder) {
this.channelLogger = builder.channelLogger;
this.executor = builder.executor;
this.overrideAuthority = builder.overrideAuthority;
- this.metricRecorder = builder.metricRecorder;
+ this.metricRecorder = builder.metricRecorder != null ? builder.metricRecorder
+ : new MetricRecorder() {};
this.nameResolverRegistry = builder.nameResolverRegistry;
this.customArgs = cloneCustomArgs(builder.customArgs);
}
@@ -456,7 +498,6 @@ public String getOverrideAuthority() {
/**
* Returns the {@link MetricRecorder} that the channel uses to record metrics.
*/
- @Nullable
public MetricRecorder getMetricRecorder() {
return metricRecorder;
}
@@ -639,7 +680,7 @@ public Builder setArg(Key key, T value) {
* See {@link Args#getMetricRecorder()}. This is an optional field.
*/
public Builder setMetricRecorder(MetricRecorder metricRecorder) {
- this.metricRecorder = metricRecorder;
+ this.metricRecorder = checkNotNull(metricRecorder, "metricRecorder");
return this;
}
diff --git a/api/src/main/java/io/grpc/NameResolverProvider.java b/api/src/main/java/io/grpc/NameResolverProvider.java
index 70e22e366d5..220fa4edc10 100644
--- a/api/src/main/java/io/grpc/NameResolverProvider.java
+++ b/api/src/main/java/io/grpc/NameResolverProvider.java
@@ -65,7 +65,7 @@ public abstract class NameResolverProvider extends NameResolver.Factory {
*
* @since 1.40.0
* */
- protected String getScheme() {
+ public String getScheme() {
return getDefaultScheme();
}
diff --git a/api/src/main/java/io/grpc/NameResolverRegistry.java b/api/src/main/java/io/grpc/NameResolverRegistry.java
index 26eb5552b9b..c5e9f7467ab 100644
--- a/api/src/main/java/io/grpc/NameResolverRegistry.java
+++ b/api/src/main/java/io/grpc/NameResolverRegistry.java
@@ -29,6 +29,7 @@
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.ServiceLoader;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
@@ -125,8 +126,10 @@ public static synchronized NameResolverRegistry getDefaultRegistry() {
if (instance == null) {
List providerList = ServiceProviders.loadAll(
NameResolverProvider.class,
- getHardCodedClasses(),
- NameResolverProvider.class.getClassLoader(),
+ ServiceLoader
+ .load(NameResolverProvider.class, NameResolverProvider.class.getClassLoader())
+ .iterator(),
+ NameResolverRegistry::getHardCodedClasses,
new NameResolverPriorityAccessor());
if (providerList.isEmpty()) {
logger.warning("No NameResolverProviders found via ServiceLoader, including for DNS. This "
@@ -182,6 +185,13 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
return provider == null ? null : provider.newNameResolver(targetUri, args);
}
+ @Override
+ @Nullable
+ public NameResolver newNameResolver(io.grpc.Uri targetUri, NameResolver.Args args) {
+ NameResolverProvider provider = getProviderForScheme(targetUri.getScheme());
+ return provider == null ? null : provider.newNameResolver(targetUri, args);
+ }
+
@Override
public String getDefaultScheme() {
return NameResolverRegistry.this.getDefaultScheme();
diff --git a/api/src/main/java/io/grpc/QueryParams.java b/api/src/main/java/io/grpc/QueryParams.java
new file mode 100644
index 00000000000..31bc2e0e6da
--- /dev/null
+++ b/api/src/main/java/io/grpc/QueryParams.java
@@ -0,0 +1,289 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Splitter;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * A parser and mutable container class for {@code application/x-www-form-urlencoded}-style URL
+ * parameters as conceived by
+ * RFC 1866 Section 8.2.1.
+ *
+ * For example, a URI like {@code "http://who?name=John+Doe&role=admin&role=user&active"} has:
+ *
+ *
+ * - A key {@code name} with value {@code John Doe}
+ *
- A key {@code role} with value {@code admin}
+ *
- A second key named {@code role} with value {@code user}
+ *
- "Lone" key {@code active} without a value.
+ *
+ *
+ * This class is meant to be used with {@link io.grpc.Uri}. For example:
+ *
+ *
{@code
+ * Uri uri = Uri.parse("http://who?name=John+Doe&role=admin&role=user&active");
+ * QueryParams params = QueryParams.fromRawQuery(uri.getRawQuery());
+ * params.asList().removeIf(e -> "role".equals(e.getKey()) && "admin".equals(e.getValue()));
+ *
+ * Uri modifiedUri = uri.toBuilder().setRawQuery(params.toRawQuery()).build();
+ * }
+ *
+ * Note that the empty collection is encoded as a null raw query string, which means "absent" to
+ * {@link io.grpc.Uri.Builder#setRawQuery}. An empty string query component (""), on the other hand,
+ * is modeled as an instance of QueryParams containing a single lone (empty) key. It must be this
+ * way if we are to simultaneously 1) support lone keys, 2) have parse/toRawQuery round-trip
+ * transparency, and 3) never fail to parse a valid RFC 3986 query component.
+ *
+ *
This container and its {@link Entry} take the same position as {@link io.grpc.Uri} on
+ * equality: raw keys and values must match exactly to be equal. Most callers won't care about how
+ * keys and values are encoded on the wire and will work with the getters for cooked keys and values
+ * instead.
+ *
+ *
Instances are not safe for concurrent access by multiple threads, including by way of the
+ * {@link #asList()} view method.
+ */
+@Internal
+public final class QueryParams {
+
+ private static final String UTF_8 = "UTF-8";
+ private final List entries = new ArrayList<>();
+
+ /** Creates a new, empty {@code QueryParams} instance. */
+ public QueryParams() {}
+
+ /**
+ * Parses a raw query string into a {@code QueryParams} instance.
+ *
+ * The input is split on {@code '&'} and each parameter is parsed as either a key/value pair
+ * (if it contains an equals sign) or a "lone" key (if it does not).
+ *
+ *
No valid RFC 3986 query component will fail to parse. For example, {@code ===} is parsed as
+ * a single parameter with "" as the key and "==" as the value. {@code &&&} is parsed as three
+ * lone keys named "". And so on. If {@code rawQuery} is not a valid RFC 3986 query component, the
+ * behavior is undefined. But if you are starting with a {@link io.grpc.Uri}, passing the value
+ * returned by {@link io.grpc.Uri#getRawQuery()} is always well-defined and will never fail.
+ *
+ *
Calling {@link #toRawQuery()} on the returned object is guaranteed to return exactly {@code
+ * rawQuery}.
+ *
+ * @param rawQuery the raw query component to parse, or null to return an empty container
+ * @return a new instance of {@code QueryParams} representing the input
+ */
+ public static QueryParams fromRawQuery(@Nullable String rawQuery) {
+ QueryParams params = new QueryParams();
+ if (rawQuery != null) {
+ for (String part : Splitter.on('&').split(rawQuery)) {
+ int equalsIndex = part.indexOf('=');
+ if (equalsIndex == -1) {
+ params.entries.add(Entry.forRawLoneKey(part));
+ } else {
+ String rawKey = part.substring(0, equalsIndex);
+ String rawValue = part.substring(equalsIndex + 1);
+ params.entries.add(Entry.forRawKeyValue(rawKey, rawValue));
+ }
+ }
+ }
+ return params;
+ }
+
+ /**
+ * Returns a mutable list view of the query parameters.
+ *
+ * @return the mutable list of entries
+ */
+ public List asList() {
+ return entries;
+ }
+
+ /**
+ * Returns the "raw" query string representation of these parameters, suitable for passing to the
+ * {@link io.grpc.Uri.Builder#setRawQuery} method.
+ *
+ * @return the raw query string
+ */
+ @Nullable
+ public String toRawQuery() {
+ if (entries.isEmpty()) {
+ return null;
+ }
+ StringBuilder resultBuilder = new StringBuilder();
+ boolean first = true;
+ for (Entry entry : entries) {
+ if (!first) {
+ resultBuilder.append('&');
+ }
+ entry.appendToRawQueryStringBuilder(resultBuilder);
+ first = false;
+ }
+ return resultBuilder.toString();
+ }
+
+ @Override
+ public String toString() {
+ return entries.toString();
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof QueryParams)) {
+ return false;
+ }
+ QueryParams other = (QueryParams) o;
+ return entries.equals(other.entries);
+ }
+
+ @Override
+ public int hashCode() {
+ return entries.hashCode();
+ }
+
+ /** A single query parameter entry. */
+ public static final class Entry {
+ private final String rawKey;
+ @Nullable private final String rawValue;
+ private final String key;
+ @Nullable private final String value;
+
+ private Entry(String rawKey, @Nullable String rawValue, String key, @Nullable String value) {
+ this.rawKey = checkNotNull(rawKey, "rawKey");
+ this.rawValue = rawValue;
+ this.key = checkNotNull(key, "key");
+ this.value = value;
+ }
+
+ /**
+ * Returns the key.
+ *
+ * Any characters that needed URL encoding have already been decoded.
+ */
+ public String getKey() {
+ return key;
+ }
+
+ /**
+ * Returns the value, or {@code null} if this is a "lone" key.
+ *
+ *
Any characters that needed URL encoding have already been decoded.
+ */
+ @Nullable
+ public String getValue() {
+ return value;
+ }
+
+ /** Returns {@code true} if this entry has a value, {@code false} if it is a "lone" key. */
+ public boolean hasValue() {
+ return value != null;
+ }
+
+ /**
+ * Creates a new key/value pair entry.
+ *
+ *
Both key and value can contain any character. They will be URL encoded for you if
+ * necessary.
+ */
+ public static Entry forKeyValue(String key, String value) {
+ checkNotNull(key, "key");
+ checkNotNull(value, "value");
+ return new Entry(encode(key), encode(value), key, value);
+ }
+
+ /**
+ * Creates a new query parameter with a "lone" key.
+ *
+ *
'key' can contain any character. It will be URL encoded for you later, as necessary.
+ *
+ * @param key the decoded key, must not be null
+ * @return a new {@code Entry}
+ */
+ public static Entry forLoneKey(String key) {
+ checkNotNull(key, "key");
+ return new Entry(encode(key), null, key, null);
+ }
+
+ static Entry forRawKeyValue(String rawKey, String rawValue) {
+ checkNotNull(rawKey, "rawKey");
+ checkNotNull(rawValue, "rawValue");
+ return new Entry(rawKey, rawValue, decode(rawKey), decode(rawValue));
+ }
+
+ static Entry forRawLoneKey(String rawKey) {
+ checkNotNull(rawKey, "rawKey");
+ return new Entry(rawKey, null, decode(rawKey), null);
+ }
+
+ void appendToRawQueryStringBuilder(StringBuilder sb) {
+ sb.append(rawKey);
+ if (rawValue != null) {
+ sb.append('=').append(rawValue);
+ }
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof Entry)) {
+ return false;
+ }
+ Entry entry = (Entry) o;
+ return Objects.equals(rawKey, entry.rawKey) && Objects.equals(rawValue, entry.rawValue);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(rawKey, rawValue);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ appendToRawQueryStringBuilder(sb);
+ return sb.toString();
+ }
+ }
+
+ private static String decode(String s) {
+ try {
+ // TODO: Use URLDecoder.decode(String, Charset) when available
+ return URLDecoder.decode(s, UTF_8);
+ } catch (UnsupportedEncodingException impossible) {
+ throw new AssertionError("UTF-8 is not supported", impossible);
+ }
+ }
+
+ private static String encode(String s) {
+ try {
+ // TODO: Use URLEncoder.encode(String, Charset) when available
+ return URLEncoder.encode(s, UTF_8);
+ } catch (UnsupportedEncodingException impossible) {
+ throw new AssertionError("UTF-8 is not supported", impossible);
+ }
+ }
+}
diff --git a/api/src/main/java/io/grpc/Server.java b/api/src/main/java/io/grpc/Server.java
index 97ea06a81c2..97c4d495b8a 100644
--- a/api/src/main/java/io/grpc/Server.java
+++ b/api/src/main/java/io/grpc/Server.java
@@ -21,13 +21,13 @@
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
-import javax.annotation.concurrent.ThreadSafe;
/**
* Server for listening for and dispatching incoming calls. It is not expected to be implemented by
* application code or interceptors.
+ *
+ *
This class is thread-safe.
*/
-@ThreadSafe
public abstract class Server {
/**
diff --git a/api/src/main/java/io/grpc/ServerBuilder.java b/api/src/main/java/io/grpc/ServerBuilder.java
index cd1cddbb93f..3effe593e57 100644
--- a/api/src/main/java/io/grpc/ServerBuilder.java
+++ b/api/src/main/java/io/grpc/ServerBuilder.java
@@ -435,6 +435,17 @@ public T setBinaryLog(BinaryLog binaryLog) {
*/
public abstract Server build();
+ /**
+ * Adds a metric sink to the server.
+ *
+ * @param metricSink the metric sink to add.
+ * @return this
+ */
+ @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12693")
+ public T addMetricSink(MetricSink metricSink) {
+ return thisT();
+ }
+
/**
* Returns the correctly typed version of the builder.
*/
diff --git a/api/src/main/java/io/grpc/ServerCallHandler.java b/api/src/main/java/io/grpc/ServerCallHandler.java
index fdfa9997957..7d7d8217300 100644
--- a/api/src/main/java/io/grpc/ServerCallHandler.java
+++ b/api/src/main/java/io/grpc/ServerCallHandler.java
@@ -16,13 +16,12 @@
package io.grpc;
-import javax.annotation.concurrent.ThreadSafe;
-
/**
* Interface to initiate processing of incoming remote calls. Advanced applications and generated
* code will implement this interface to allows {@link Server}s to invoke service methods.
+ *
+ *
This interface is thread-safe.
*/
-@ThreadSafe
public interface ServerCallHandler {
/**
* Starts asynchronous processing of an incoming call.
diff --git a/api/src/main/java/io/grpc/ServerInterceptor.java b/api/src/main/java/io/grpc/ServerInterceptor.java
index 9b2e76ef608..2944cf680fe 100644
--- a/api/src/main/java/io/grpc/ServerInterceptor.java
+++ b/api/src/main/java/io/grpc/ServerInterceptor.java
@@ -16,7 +16,6 @@
package io.grpc;
-import javax.annotation.concurrent.ThreadSafe;
/**
* Interface for intercepting incoming calls before they are dispatched by
@@ -34,8 +33,9 @@
* without completing the previous ones first. Refer to the
* {@link io.grpc.ServerCall.Listener ServerCall.Listener} docs for more details regarding thread
* safety of the returned listener.
+ *
+ * This interface is thread-safe.
*/
-@ThreadSafe
public interface ServerInterceptor {
/**
* Intercept {@link ServerCall} dispatch by the {@code next} {@link ServerCallHandler}. General
diff --git a/api/src/main/java/io/grpc/ServerRegistry.java b/api/src/main/java/io/grpc/ServerRegistry.java
index 5b9c8c558e7..1ec7030b82b 100644
--- a/api/src/main/java/io/grpc/ServerRegistry.java
+++ b/api/src/main/java/io/grpc/ServerRegistry.java
@@ -24,6 +24,7 @@
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
+import java.util.ServiceLoader;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.concurrent.ThreadSafe;
@@ -93,8 +94,9 @@ public static synchronized ServerRegistry getDefaultRegistry() {
if (instance == null) {
List providerList = ServiceProviders.loadAll(
ServerProvider.class,
- getHardCodedClasses(),
- ServerProvider.class.getClassLoader(),
+ ServiceLoader.load(ServerProvider.class, ServerProvider.class.getClassLoader())
+ .iterator(),
+ ServerRegistry::getHardCodedClasses,
new ServerPriorityAccessor());
instance = new ServerRegistry();
for (ServerProvider provider : providerList) {
diff --git a/api/src/main/java/io/grpc/ServerStreamTracer.java b/api/src/main/java/io/grpc/ServerStreamTracer.java
index d522610ab3a..81691642131 100644
--- a/api/src/main/java/io/grpc/ServerStreamTracer.java
+++ b/api/src/main/java/io/grpc/ServerStreamTracer.java
@@ -17,13 +17,13 @@
package io.grpc;
import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
/**
* Listens to events on a stream to collect metrics.
+ *
+ * This class is thread-safe.
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
-@ThreadSafe
public abstract class ServerStreamTracer extends StreamTracer {
/**
* Called before the interceptors and the call handlers and make changes to the Context object
diff --git a/api/src/main/java/io/grpc/ServiceProviders.java b/api/src/main/java/io/grpc/ServiceProviders.java
index ac4b27d8783..861688be9fb 100644
--- a/api/src/main/java/io/grpc/ServiceProviders.java
+++ b/api/src/main/java/io/grpc/ServiceProviders.java
@@ -17,10 +17,13 @@
package io.grpc;
import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Supplier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
+import java.util.Iterator;
import java.util.List;
+import java.util.ListIterator;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
@@ -29,42 +32,44 @@ private ServiceProviders() {
// do not instantiate
}
- /**
- * If this is not Android, returns the highest priority implementation of the class via
- * {@link ServiceLoader}.
- * If this is Android, returns an instance of the highest priority class in {@code hardcoded}.
- */
- public static T load(
- Class klass,
- Iterable> hardcoded,
- ClassLoader cl,
- PriorityAccessor priorityAccessor) {
- List candidates = loadAll(klass, hardcoded, cl, priorityAccessor);
- if (candidates.isEmpty()) {
- return null;
- }
- return candidates.get(0);
- }
-
/**
* If this is not Android, returns all available implementations discovered via
* {@link ServiceLoader}.
* If this is Android, returns all available implementations in {@code hardcoded}.
* The list is sorted in descending priority order.
+ *
+ * {@code serviceLoader} should be created with {@code ServiceLoader.load(MyClass.class,
+ * MyClass.class.getClassLoader()).iterator()} in order to be detected by R8 so that R8 full mode
+ * will keep the constructors for the provider classes.
*/
public static List loadAll(
Class klass,
- Iterable> hardcoded,
- ClassLoader cl,
+ Iterator serviceLoader,
+ Supplier>> hardcoded,
final PriorityAccessor priorityAccessor) {
- Iterable candidates;
- if (isAndroid(cl)) {
- candidates = getCandidatesViaHardCoded(klass, hardcoded);
+ Iterator candidates;
+ if (serviceLoader instanceof ListIterator) {
+ // A rewriting tool has replaced the ServiceLoader with a List of some sort (R8 uses
+ // ArrayList, AppReduce uses singletonList). We prefer to use such iterators on Android as
+ // they won't need reflection like the hard-coded list does. In addition, the provider
+ // instances will have already been created, so it seems we should use them.
+ //
+ // R8: https://r8.googlesource.com/r8/+/490bc53d9310d4cc2a5084c05df4aadaec8c885d/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
+ // AppReduce: service_loader_pass.cc
+ candidates = serviceLoader;
+ } else if (isAndroid(klass.getClassLoader())) {
+ // Avoid getResource() on Android, which must read from a zip which uses a lot of memory
+ candidates = getCandidatesViaHardCoded(klass, hardcoded.get()).iterator();
+ } else if (!serviceLoader.hasNext()) {
+ // Attempt to load using the context class loader and ServiceLoader.
+ // This allows frameworks like http://aries.apache.org/modules/spi-fly.html to plug in.
+ candidates = ServiceLoader.load(klass).iterator();
} else {
- candidates = getCandidatesViaServiceLoader(klass, cl);
+ candidates = serviceLoader;
}
List list = new ArrayList<>();
- for (T current: candidates) {
+ while (candidates.hasNext()) {
+ T current = candidates.next();
if (!priorityAccessor.isAvailable(current)) {
continue;
}
@@ -101,15 +106,14 @@ static boolean isAndroid(ClassLoader cl) {
}
/**
- * Loads service providers for the {@code klass} service using {@link ServiceLoader}.
+ * For testing only: Loads service providers for the {@code klass} service using {@link
+ * ServiceLoader}. Does not support spi-fly and related tricks.
*/
@VisibleForTesting
public static Iterable getCandidatesViaServiceLoader(Class klass, ClassLoader cl) {
Iterable i = ServiceLoader.load(klass, cl);
- // Attempt to load using the context class loader and ServiceLoader.
- // This allows frameworks like http://aries.apache.org/modules/spi-fly.html to plug in.
if (!i.iterator().hasNext()) {
- i = ServiceLoader.load(klass);
+ return null;
}
return i;
}
diff --git a/api/src/main/java/io/grpc/StatusException.java b/api/src/main/java/io/grpc/StatusException.java
index 2a235c3aaaf..c0a67a375b2 100644
--- a/api/src/main/java/io/grpc/StatusException.java
+++ b/api/src/main/java/io/grpc/StatusException.java
@@ -65,6 +65,7 @@ public final Status getStatus() {
*
* @since 1.0.0
*/
+ @Nullable
public final Metadata getTrailers() {
return trailers;
}
diff --git a/api/src/main/java/io/grpc/StatusOr.java b/api/src/main/java/io/grpc/StatusOr.java
index 0f1e9da3c75..b7dd68cfd7b 100644
--- a/api/src/main/java/io/grpc/StatusOr.java
+++ b/api/src/main/java/io/grpc/StatusOr.java
@@ -33,7 +33,7 @@ private StatusOr(Status status, T value) {
}
/** Construct from a value. */
- public static StatusOr fromValue(@Nullable T value) {
+ public static StatusOr fromValue(T value) {
StatusOr result = new StatusOr(null, value);
return result;
}
@@ -54,7 +54,7 @@ public boolean hasValue() {
* Returns the value if set or throws exception if there is no value set. This method is meant
* to be called after checking the return value of hasValue() first.
*/
- public @Nullable T getValue() {
+ public T getValue() {
if (status != null) {
throw new IllegalStateException("No value present.");
}
@@ -105,6 +105,7 @@ public String toString() {
return stringHelper.toString();
}
+ @Nullable
private final Status status;
private final T value;
}
diff --git a/api/src/main/java/io/grpc/StreamTracer.java b/api/src/main/java/io/grpc/StreamTracer.java
index 66b3de8be6b..251e6e2b49f 100644
--- a/api/src/main/java/io/grpc/StreamTracer.java
+++ b/api/src/main/java/io/grpc/StreamTracer.java
@@ -16,15 +16,14 @@
package io.grpc;
-import javax.annotation.concurrent.ThreadSafe;
-
/**
* Listens to events on a stream to collect metrics.
*
* DO NOT MOCK: Use TestStreamTracer. Mocks are not thread-safe
+ *
+ *
This class is thread-safe.
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
-@ThreadSafe
public abstract class StreamTracer {
/**
* Stream is closed. This will be called exactly once.
diff --git a/api/src/main/java/io/grpc/Uri.java b/api/src/main/java/io/grpc/Uri.java
new file mode 100644
index 00000000000..a88bb6138d8
--- /dev/null
+++ b/api/src/main/java/io/grpc/Uri.java
@@ -0,0 +1,1184 @@
+/*
+ * Copyright 2025 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableList;
+import com.google.common.net.InetAddresses;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import java.net.InetAddress;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.MalformedInputException;
+import java.nio.charset.StandardCharsets;
+import java.util.BitSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * A not-quite-general-purpose representation of a Uniform Resource Identifier (URI), as defined by
+ * RFC 3986.
+ *
+ *
The URI
+ *
+ * A URI identifies a resource by its name or location or both. The resource could be a file,
+ * service, or some other abstract entity.
+ *
+ *
Examples
+ *
+ *
+ * http://admin@example.com:8080/controlpanel?filter=users#settings
+ * ftp://[2001:db8::7]/docs/report.pdf
+ * file:///My%20Computer/Documents/letter.doc
+ * dns://8.8.8.8/storage.googleapis.com
+ * mailto:John.Doe@example.com
+ * tel:+1-206-555-1212
+ * urn:isbn:978-1492082798
+ *
+ *
+ * Limitations
+ *
+ * This class aims to meet the needs of grpc-java itself and RPC related code that depend on it.
+ * It isn't quite general-purpose. It definitely would not be suitable for building an HTTP user
+ * agent or proxy server. In particular, it:
+ *
+ *
+ * - Can only represent a URI, not a "URI-reference" or "relative reference". In other words, a
+ * "scheme" is always required.
+ *
- Has no knowledge of the particulars of any scheme, with respect to normalization and
+ * comparison. We don't know
https://google.com is the same as
+ * https://google.com:443, that file:/// is the same as
+ * file://localhost, or that joe@example.com is the same as
+ * joe@EXAMPLE.COM. No one class can or should know everything about every scheme so
+ * all this is better handled at a higher layer.
+ * - Implements {@link #equals(Object)} as a char-by-char comparison. Expect false negatives.
+ *
- Does not support "IPvFuture" literal addresses.
+ *
- Does not reflect how web browsers parse user input or the URL Living Standard.
+ *
- Does not support different character encodings. Assumes UTF-8 in several places.
+ *
+ *
+ * Migrating from RFC 2396 and {@link java.net.URI}
+ *
+ * Those migrating from {@link java.net.URI} and/or its primary specification in RFC 2396 should
+ * note some differences.
+ *
+ *
Uniform Hierarchical Syntax
+ *
+ * RFC 3986 unifies the older ideas of "hierarchical" and "opaque" URIs into a single generic
+ * syntax. What RFC 2396 called an opaque "scheme-specific part" is always broken out by RFC 3986
+ * into an authority and path hierarchy, followed by query and fragment components. Accordingly,
+ * this class has only getters for those components but no {@link
+ * java.net.URI#getSchemeSpecificPart()} analog.
+ *
+ *
The RFC 3986 definition of path is now more liberal to accommodate this:
+ *
+ *
+ * - Path doesn't have to start with a slash. For example, the path of
+ * urn:isbn:978-1492082798 is isbn:978-1492082798 even though it doesn't
+ * look much like a file system path.
+ * - The path can now be empty. So Android's
+ * intent:#Intent;action=MAIN;category=LAUNCHER;end is now a valid {@link Uri}. Even
+ * the scheme-only about: is now valid.
+ *
+ *
+ * The uniform syntax always understands what follows a '?' to be a query string. For example,
+ * mailto:me@example.com?subject=foo now has a query component whereas RFC 2396
+ * considered everything after the mailto: scheme to be opaque.
+ *
+ *
Same goes for fragment. data:image/png;...#xywh=0,0,10,10 now has a fragment
+ * whereas RFC 2396 considered everything after the scheme to be opaque.
+ *
+ *
Uniform Authority Syntax
+ *
+ * RFC 2396 tried to guess if an authority was a "server" (host:port) or "registry-based"
+ * (arbitrary string) based on its contents. RFC 3986 expects every authority to look like
+ * [userinfo@]host[:port] and loosens the definition of a "host" to accommodate. Accordingly, this
+ * class has no equivalent to {@link java.net.URI#parseServerAuthority()} -- authority was parsed
+ * into its components and checked for validity when the {@link Uri} was created.
+ *
+ *
Other Specific Differences
+ *
+ * RFC 2396 does not allow underscores in a host name, meaning {@link java.net.URI} switches to
+ * opaque mode when it sees one. {@link Uri} does allow underscores in host, to accommodate
+ * registries other than DNS. So http://my_site.com:8080/index.html now parses as a
+ * host, port and path rather than a single opaque scheme-specific part.
+ *
+ *
{@link Uri} strictly *requires* square brackets in the query string and fragment to be
+ * percent-encoded whereas RFC 2396 merely recommended doing so.
+ *
+ *
Other URx classes are "liberal in what they accept and strict in what they produce." {@link
+ * Uri#parse(String)} and {@link Uri#create(String)}, however, are strict in what they accept and
+ * transparent when asked to reproduce it via {@link Uri#toString()}. The former policy may be
+ * appropriate for parsing user input or web content, but this class is meant for gRPC clients,
+ * servers and plugins like name resolvers where human error at runtime is less likely and best
+ * detected early. {@link java.net.URI#create(String)} is similarly strict, which makes migration
+ * easy, except for the server/registry-based ambiguity addressed by {@link
+ * java.net.URI#parseServerAuthority()}.
+ *
+ *
{@link java.net.URI} and {@link Uri} both support IPv6 literals in square brackets as defined
+ * by RFC 2732.
+ *
+ *
{@link java.net.URI} supports IPv6 scope IDs but accepts and emits a non-standard syntax.
+ * {@link Uri} implements the newer RFC 6874, which percent encodes scope IDs and the % delimiter
+ * itself. RFC 9844 claims to obsolete RFC 6874 because web browsers would not support it. This
+ * class implements RFC 6874 anyway, mostly to avoid creating a barrier to migration away from
+ * {@link java.net.URI}.
+ *
+ *
Some URI components, e.g. scheme, are required while others may or may not be present, e.g.
+ * authority. {@link Uri} is careful to preserve the distinction between an absent string component
+ * (getter returns null) and one with an empty value (getter returns ""). {@link java.net.URI} makes
+ * this distinction too, *except* when it comes to the authority and host components: {@link
+ * java.net.URI#getAuthority()} and {@link java.net.URI#getHost()} return null when an authority is
+ * absent, e.g. file:/path as expected. But these methods surprisingly also return null
+ * when the authority is the empty string, e.g.file:///path. {@link Uri}'s getters
+ * correctly return null and "" in these cases, respectively, as one would expect.
+ */
+@Internal
+public final class Uri {
+ // Components are stored percent-encoded, just as originally parsed for transparent parse/toString
+ // round-tripping.
+ private final String scheme; // != null since we don't support relative references.
+ @Nullable private final String userInfo;
+ @Nullable private final String host;
+ @Nullable private final String port;
+ private final String path; // In RFC 3986, path is always defined (but can be empty).
+ @Nullable private final String query;
+ @Nullable private final String fragment;
+
+ private Uri(Builder builder) {
+ this.scheme = checkNotNull(builder.scheme, "scheme");
+ this.userInfo = builder.userInfo;
+ this.host = builder.host;
+ this.port = builder.port;
+ this.path = builder.path;
+ this.query = builder.query;
+ this.fragment = builder.fragment;
+
+ // Checks common to the parse() and Builder code paths.
+ if (hasAuthority()) {
+ if (!path.isEmpty() && !path.startsWith("/")) {
+ throw new IllegalArgumentException("Has authority -- Non-empty path must start with '/'");
+ }
+ } else {
+ if (path.startsWith("//")) {
+ throw new IllegalArgumentException("No authority -- Path cannot start with '//'");
+ }
+ }
+ }
+
+ /**
+ * Parses a URI from its string form.
+ *
+ * @throws URISyntaxException if 's' is not a valid RFC 3986 URI.
+ */
+ public static Uri parse(String s) throws URISyntaxException {
+ try {
+ return create(s);
+ } catch (IllegalArgumentException e) {
+ throw new URISyntaxException(s, e.getMessage());
+ }
+ }
+
+ /**
+ * Creates a URI from a string assumed to be valid.
+ *
+ *
Useful for defining URI constants in code. Not for user input.
+ *
+ * @throws IllegalArgumentException if 's' is not a valid RFC 3986 URI.
+ */
+ public static Uri create(String s) {
+ Builder builder = new Builder();
+ int i = 0;
+ final int n = s.length();
+
+ // 3.1. Scheme: Look for a ':' before '/', '?', or '#'.
+ int schemeColon = -1;
+ for (; i < n; ++i) {
+ char c = s.charAt(i);
+ if (c == ':') {
+ schemeColon = i;
+ break;
+ } else if (c == '/' || c == '?' || c == '#') {
+ break;
+ }
+ }
+ if (schemeColon < 0) {
+ throw new IllegalArgumentException("Missing required scheme.");
+ }
+ builder.setRawScheme(s.substring(0, schemeColon));
+
+ // 3.2. Authority. Look for '//' then keep scanning until '/', '?', or '#'.
+ i = schemeColon + 1;
+ if (i + 1 < n && s.charAt(i) == '/' && s.charAt(i + 1) == '/') {
+ // "//" just means we have an authority. Skip over it.
+ i += 2;
+
+ int authorityStart = i;
+ for (; i < n; ++i) {
+ char c = s.charAt(i);
+ if (c == '/' || c == '?' || c == '#') {
+ break;
+ }
+ }
+ builder.setRawAuthority(s.substring(authorityStart, i));
+ }
+
+ // 3.3. Path: Whatever is left before '?' or '#'.
+ int pathStart = i;
+ for (; i < n; ++i) {
+ char c = s.charAt(i);
+ if (c == '?' || c == '#') {
+ break;
+ }
+ }
+ builder.setRawPath(s.substring(pathStart, i));
+
+ // 3.4. Query, if we stopped at '?'.
+ if (i < n && s.charAt(i) == '?') {
+ i++; // Skip '?'
+ int queryStart = i;
+ for (; i < n; ++i) {
+ char c = s.charAt(i);
+ if (c == '#') {
+ break;
+ }
+ }
+ builder.setRawQuery(s.substring(queryStart, i));
+ }
+
+ // 3.5. Fragment, if we stopped at '#'.
+ if (i < n && s.charAt(i) == '#') {
+ ++i; // Skip '#'
+ builder.setRawFragment(s.substring(i));
+ }
+
+ return builder.build();
+ }
+
+ private static int findPortStartColon(String authority, int hostStart) {
+ for (int i = authority.length() - 1; i >= hostStart; --i) {
+ char c = authority.charAt(i);
+ if (c == ':') {
+ return i;
+ }
+ if (c == ']') {
+ // Hit the end of IP-literal. Any further colon is inside it and couldn't indicate a port.
+ break;
+ }
+ if (!digitChars.get(c)) {
+ // Found a non-digit, non-colon, non-bracket.
+ // This means there is no valid port (e.g. host is "example.com")
+ break;
+ }
+ }
+ return -1;
+ }
+
+ // Checks a raw path for validity and parses it into segments. Let 'out' be null to just validate.
+ private static void parseAssumedUtf8PathIntoSegments(
+ String path, ImmutableList.Builder out) {
+ // Skip the first slash so it doesn't count as an empty segment at the start.
+ // (e.g., "/a" -> ["a"], not ["", "a"])
+ int start = path.startsWith("/") ? 1 : 0;
+
+ for (int i = start; i < path.length(); ) {
+ int nextSlash = path.indexOf('/', i);
+ String segment;
+ if (nextSlash >= 0) {
+ // Typical segment case (e.g., "foo" in "/foo/bar").
+ segment = path.substring(i, nextSlash);
+ i = nextSlash + 1;
+ } else {
+ // Final segment case (e.g., "bar" in "/foo/bar").
+ segment = path.substring(i);
+ i = path.length();
+ }
+ if (out != null) {
+ out.add(percentDecodeAssumedUtf8(segment));
+ } else {
+ checkPercentEncodedArg(segment, "path segment", pChars);
+ }
+ }
+
+ // RFC 3986 says a trailing slash creates a final empty segment.
+ // (e.g., "/foo/" -> ["foo", ""])
+ if (path.endsWith("/") && out != null) {
+ out.add("");
+ }
+ }
+
+ /** Returns the scheme of this URI. */
+ public String getScheme() {
+ return scheme;
+ }
+
+ /**
+ * Returns the percent-decoded "Authority" component of this URI, or null if not present.
+ *
+ * NB: This method's decoding is lossy -- It only exists for compatibility with {@link
+ * java.net.URI}. Prefer {@link #getRawAuthority()} or work instead with authority in terms of its
+ * individual components ({@link #getUserInfo()}, {@link #getHost()} and {@link #getPort()}). The
+ * problem with getAuthority() is that it returns the delimited concatenation of the percent-
+ * decoded userinfo, host and port components. But both userinfo and host can contain the '@'
+ * character, which becomes indistinguishable from the userinfo/host delimiter after decoding. For
+ * example, URIs scheme://x@y%40z and scheme://x%40y@z have different
+ * userinfo and host components but getAuthority() returns "x@y@z" for both of them.
+ *
+ *
NB: This method assumes the "host" component was encoded as UTF-8, as mandated by RFC 3986.
+ * This method also assumes the "user information" part of authority was encoded as UTF-8,
+ * although RFC 3986 doesn't specify an encoding.
+ *
+ *
Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+ * the output. Callers who want to detect and handle errors in some other way should call {@link
+ * #getRawAuthority()}, {@link #percentDecode(CharSequence)}, then decode the bytes for
+ * themselves.
+ */
+ @Nullable
+ public String getAuthority() {
+ return percentDecodeAssumedUtf8(getRawAuthority());
+ }
+
+ private boolean hasAuthority() {
+ return host != null;
+ }
+
+ /**
+ * Returns the "authority" component of this URI in its originally parsed, possibly
+ * percent-encoded form.
+ */
+ @Nullable
+ public String getRawAuthority() {
+ if (hasAuthority()) {
+ StringBuilder sb = new StringBuilder();
+ appendAuthority(sb);
+ return sb.toString();
+ }
+ return null;
+ }
+
+ private void appendAuthority(StringBuilder sb) {
+ if (userInfo != null) {
+ sb.append(userInfo).append('@');
+ }
+ if (host != null) {
+ sb.append(host);
+ }
+ if (port != null) {
+ sb.append(':').append(port);
+ }
+ }
+
+ /**
+ * Returns the percent-decoded "User Information" component of this URI, or null if not present.
+ *
+ *
NB: This method *assumes* this component was encoded as UTF-8, although RFC 3986 doesn't
+ * specify an encoding.
+ *
+ *
Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+ * the output. Callers who want to detect and handle errors in some other way should call {@link
+ * #getRawUserInfo()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+ */
+ @Nullable
+ public String getUserInfo() {
+ return percentDecodeAssumedUtf8(userInfo);
+ }
+
+ /**
+ * Returns the "User Information" component of this URI in its originally parsed, possibly
+ * percent-encoded form.
+ */
+ @Nullable
+ public String getRawUserInfo() {
+ return userInfo;
+ }
+
+ /**
+ * Returns the percent-decoded "host" component of this URI, or null if not present.
+ *
+ *
This method assumes the host was encoded as UTF-8, as mandated by RFC 3986.
+ *
+ *
Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+ * the output. Callers who want to detect and handle errors in some other way should call {@link
+ * #getRawHost()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+ */
+ @Nullable
+ public String getHost() {
+ return percentDecodeAssumedUtf8(host);
+ }
+
+ /**
+ * Returns the host component of this URI in its originally parsed, possibly percent-encoded form.
+ */
+ @Nullable
+ public String getRawHost() {
+ return host;
+ }
+
+ /** Returns the "port" component of this URI, or -1 if empty or not present. */
+ public int getPort() {
+ return port != null && !port.isEmpty() ? Integer.parseInt(port) : -1;
+ }
+
+ /** Returns the raw port component of this URI in its originally parsed form. */
+ @Nullable
+ public String getRawPort() {
+ return port;
+ }
+
+ /**
+ * Returns the (possibly empty) percent-decoded "path" component of this URI.
+ *
+ *
NB: This method *assumes* the path was encoded as UTF-8, although RFC 3986 doesn't specify
+ * an encoding.
+ *
+ *
Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+ * the output. Callers who want to detect and handle errors in some other way should call {@link
+ * #getRawPath()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+ *
+ *
NB: Prefer {@link #getPathSegments()} because this method's decoding is lossy. For example,
+ * consider these (different) URIs:
+ *
+ *
+ * - file:///home%2Ffolder/my%20file
+ *
- file:///home/folder/my%20file
+ *
+ *
+ * Calling getPath() on each returns the same string: /home/folder/my file. You
+ * can't tell whether the second '/' character is part of the first path segment or separates the
+ * first and second path segments. This method only exists to ease migration from {@link
+ * java.net.URI}.
+ */
+ public String getPath() {
+ return percentDecodeAssumedUtf8(path);
+ }
+
+ /**
+ * Returns this URI's path as a list of path segments not including the '/' segment delimiters.
+ *
+ *
Prefer this method over {@link #getPath()} because it preserves the distinction between
+ * segment separators and literal '/'s within a path segment.
+ *
+ *
A trailing '/' delimiter in the path results in the empty string as the last element in the
+ * returned list. For example, file://localhost/foo/bar/ has path segments
+ * ["foo", "bar", ""]
+ *
+ *
A leading '/' delimiter cannot be detected using this method. For example, both
+ * dns:example.com and dns:///example.com have the same list of path segments:
+ * ["example.com"]. Use {@link #isPathAbsolute()} or {@link #isPathRootless()} to
+ * distinguish these cases.
+ *
+ *
The returned list is immutable.
+ */
+ public List getPathSegments() {
+ // Returned list must be immutable but we intentionally keep guava out of the public API.
+ ImmutableList.Builder segmentsBuilder = ImmutableList.builder();
+ parseAssumedUtf8PathIntoSegments(path, segmentsBuilder);
+ return segmentsBuilder.build();
+ }
+
+ /**
+ * Returns true iff this URI's path component starts with a path segment (rather than the '/'
+ * segment delimiter).
+ *
+ * The path of an RFC 3986 URI is either empty, absolute (starts with the '/' segment
+ * delimiter) or rootless (starts with a path segment). For example, tel:+1-206-555-1212
+ * , mailto:me@example.com and urn:isbn:978-1492082798 all have
+ * rootless paths. mailto:%2Fdev%2Fnull@example.com is also rootless because its
+ * percent-encoded slashes are not segment delimiters but rather part of the first and only path
+ * segment.
+ *
+ *
Contrast rootless paths with absolute ones (see {@link #isPathAbsolute()}.
+ */
+ public boolean isPathRootless() {
+ return !path.isEmpty() && !path.startsWith("/");
+ }
+
+ /**
+ * Returns true iff this URI's path component starts with the '/' segment delimiter (rather than a
+ * path segment).
+ *
+ *
The path of an RFC 3986 URI is either empty, absolute (starts with the '/' segment
+ * delimiter) or rootless (starts with a path segment). For example, file:///resume.txt
+ * , file:/resume.txt and file://localhost/ all have absolute
+ * paths while tel:+1-206-555-1212's path is not absolute.
+ * mailto:%2Fdev%2Fnull@example.com is also not absolute because its percent-encoded
+ * slashes are not segment delimiters but rather part of the first and only path segment.
+ *
+ *
Contrast absolute paths with rootless ones (see {@link #isPathRootless()}.
+ *
+ *
NB: The term "absolute" has two different meanings in RFC 3986 which are easily confused.
+ * This method tests for a property of this URI's path component. Contrast with {@link
+ * #isAbsolute()} which tests the URI itself for a different property.
+ */
+ public boolean isPathAbsolute() {
+ return path.startsWith("/");
+ }
+
+ /**
+ * Returns the path component of this URI in its originally parsed, possibly percent-encoded form.
+ */
+ public String getRawPath() {
+ return path;
+ }
+
+ /**
+ * Returns the query component of this URI in its originally parsed, possibly percent-encoded
+ * form, without any leading '?' character, or null if not present.
+ *
+ *
The query component can only be read in its raw form. That’s because virtually everyone uses
+ * query as a container for structured data, with some additional layer of encoding not present in
+ * RFC-3986. Like 'application/x-www-form-urlencoded', which encodes key/value pairs like so:
+ * ?k1=v1&k2=v+2. The encoding of these containers always has characters that take on
+ * a special delimiter meaning when not percent-encoded and a literal meaning when they are (like
+ * '&', '=' and '+' above). Since it matters whether a character was percent encoded or not,
+ * offering a '#getQuery()' method that percent-decodes everything like we do for other components
+ * would be error-prone.
+ */
+ @Nullable
+ public String getRawQuery() {
+ return query;
+ }
+
+ /**
+ * Returns the percent-decoded "fragment" component of this URI, or null if not present.
+ *
+ *
NB: This method assumes the fragment was encoded as UTF-8, although RFC 3986 doesn't specify
+ * an encoding.
+ *
+ *
Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+ * the output. Callers who want to detect and handle errors in some other way should call {@link
+ * #getRawFragment()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+ *
+ *
NB: Choose carefully between this method and {@link #getRawFragment()}. Many URI schemes
+ * embed further structure inside the fragment that isn't part of the RFC 3986 generic syntax. For
+ * example, Android uses the fragment to encode the many fields of an Intent, like {@code
+ * intent:#Intent;S.key=val;end;}. And the URI of a JSON resource may use RFC 6901 in its fragment
+ * to point at a particular node, e.g. {@code
+ * file:/etc/config/service.json#/methodConfig/0/retryPolicy/maxBackoff}.
+ *
+ *
When percent-encoding is used to escape internal delimiters, like a literal ';' and '=' in
+ * an `intent:`, call {@link #getRawFragment()} to preserve that percent-encoding, or risk
+ * corruption. Conversely, use *this* method when percent-decoding is needed *before* any further
+ * interpretation, like with a JSON pointer, which must be percent-encoded in a URI fragment but
+ * uses a completely different method of escaping literal '/' characters.
+ */
+ @Nullable
+ public String getFragment() {
+ return percentDecodeAssumedUtf8(fragment);
+ }
+
+ /**
+ * Returns the fragment component of this URI in its original, possibly percent-encoded form, and
+ * without any leading '#' character.
+ *
+ *
NB: Choose carefully between this method and {@link #getFragment()}. See that Javadoc for
+ * details.
+ */
+ @Nullable
+ public String getRawFragment() {
+ return fragment;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ *
If this URI was created by {@link #parse(String)} or {@link #create(String)}, then the
+ * returned string will match that original input exactly.
+ */
+ @Override
+ public String toString() {
+ // https://datatracker.ietf.org/doc/html/rfc3986#section-5.3
+ StringBuilder sb = new StringBuilder();
+ sb.append(scheme).append(':');
+ if (hasAuthority()) {
+ sb.append("//");
+ appendAuthority(sb);
+ }
+ sb.append(path);
+ if (query != null) {
+ sb.append('?').append(query);
+ }
+ if (fragment != null) {
+ sb.append('#').append(fragment);
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Returns true iff this URI has a scheme and an authority/path hierarchy, but no fragment.
+ *
+ *
All instances of {@link Uri} are RFC 3986 URIs, not "relative references", so this method is
+ * equivalent to {@code getFragment() == null}. It mostly exists for compatibility with {@link
+ * java.net.URI}.
+ */
+ public boolean isAbsolute() {
+ return scheme != null && fragment == null;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ *
Two instances of {@link Uri} are equal if and only if they have the same string
+ * representation, which RFC 3986 calls "Simple String Comparison" (6.2.1). Callers with a higher
+ * layer expectation of equality (e.g. http://some%2Dhost:80/foo/./bar.txt ~=
+ * http://some-host/foo/bar.txt) will experience false negatives.
+ */
+ @Override
+ public boolean equals(Object otherObj) {
+ if (!(otherObj instanceof Uri)) {
+ return false;
+ }
+ Uri other = (Uri) otherObj;
+ return Objects.equals(scheme, other.scheme)
+ && Objects.equals(userInfo, other.userInfo)
+ && Objects.equals(host, other.host)
+ && Objects.equals(port, other.port)
+ && Objects.equals(path, other.path)
+ && Objects.equals(query, other.query)
+ && Objects.equals(fragment, other.fragment);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(scheme, userInfo, host, port, path, query, fragment);
+ }
+
+ /** Returns a new Builder initialized with the fields of this URI. */
+ public Builder toBuilder() {
+ return new Builder(this);
+ }
+
+ /** Creates a new {@link Builder} with all fields uninitialized or set to their default values. */
+ public static Builder newBuilder() {
+ return new Builder();
+ }
+
+ /** Builder for {@link Uri}. */
+ public static final class Builder {
+ private String scheme;
+ private String path = "";
+ private String query;
+ private String fragment;
+ private String userInfo;
+ private String host;
+ private String port;
+
+ private Builder() {}
+
+ Builder(Uri prototype) {
+ this.scheme = prototype.scheme;
+ this.userInfo = prototype.userInfo;
+ this.host = prototype.host;
+ this.port = prototype.port;
+ this.path = prototype.path;
+ this.query = prototype.query;
+ this.fragment = prototype.fragment;
+ }
+
+ /**
+ * Sets the scheme, e.g. "https", "dns" or "xds".
+ *
+ *
This field is required.
+ *
+ * @return this, for fluent building
+ * @throws IllegalArgumentException if the scheme is invalid.
+ */
+ @CanIgnoreReturnValue
+ public Builder setScheme(String scheme) {
+ return setRawScheme(scheme.toLowerCase(Locale.ROOT));
+ }
+
+ @CanIgnoreReturnValue
+ Builder setRawScheme(String scheme) {
+ if (scheme.isEmpty() || !alphaChars.get(scheme.charAt(0))) {
+ throw new IllegalArgumentException("Scheme must start with an alphabetic char");
+ }
+ for (int i = 0; i < scheme.length(); i++) {
+ char c = scheme.charAt(i);
+ if (!schemeChars.get(c)) {
+ throw new IllegalArgumentException("Invalid character in scheme at index " + i);
+ }
+ }
+ this.scheme = scheme;
+ return this;
+ }
+
+ /**
+ * Specifies the new URI's path component as a string of zero or more '/' delimited segments.
+ *
+ *
Path segments can consist of any string of codepoints. Codepoints that can't be encoded
+ * literally will be percent-encoded for you.
+ *
+ *
If a URI contains an authority component, then the path component must either be empty or
+ * begin with a slash ("/") character. If a URI does not contain an authority component, then
+ * the path cannot begin with two slash characters ("//").
+ *
+ *
This method interprets all '/' characters in 'path' as segment delimiters. If any of your
+ * segments contain literal '/' characters, call {@link #setRawPath(String)} instead.
+ *
+ *
See RFC 3986 3.3
+ * for more.
+ *
+ *
This field is required but can be empty (its default value).
+ *
+ * @param path the new path
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setPath(String path) {
+ checkArgument(path != null, "Path can be empty but not null");
+ this.path = percentEncode(path, pCharsAndSlash);
+ return this;
+ }
+
+ /**
+ * Specifies the new URI's path component as a string of zero or more '/' delimited segments.
+ *
+ *
Path segments can consist of any string of codepoints but the caller must first percent-
+ * encode anything other than RFC 3986's "pchar" character class using UTF-8.
+ *
+ *
If a URI contains an authority component, then the path component must either be empty or
+ * begin with a slash ("/") character. If a URI does not contain an authority component, then
+ * the path cannot begin with two slash characters ("//").
+ *
+ *
This method interprets all '/' characters in 'path' as segment delimiters. If any of your
+ * segments contain literal '/' characters, you must percent-encode them.
+ *
+ *
See RFC 3986 3.3
+ * for more.
+ *
+ *
This field is required but can be empty (its default value).
+ *
+ * @param path the new path, a string consisting of characters from "pchar"
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setRawPath(String path) {
+ checkArgument(path != null, "Path can be empty but not null");
+ parseAssumedUtf8PathIntoSegments(path, null);
+ this.path = path;
+ return this;
+ }
+
+ /**
+ * Specifies the query component of the new URI, possibly percent-encoded, exactly as it will
+ * appear in the string form of the built URI.
+ *
+ *
'query' must only contain codepoints from RFC 3986's "query" character class. Any other
+ * characters must be percent-encoded using UTF-8. Do not include the leading '?' delimiter.
+ *
+ *
The query component can only be provided in its raw form. That’s because virtually
+ * everyone uses query as a container for structured data, with some additional layer of
+ * encoding not present in RFC-3986. Like 'application/x-www-form-urlencoded', which encodes
+ * key/value pairs like so: ?k1=v1&k2=v+2. The encoding of these containers always
+ * has characters that take on a special delimiter meaning when not percent-encoded and a
+ * literal meaning when they are (like '&', '=' and '+' above). Since 'query' must have already
+ * been carefully percent-encoded externally, a '#setQuery(String)' method that percent-encodes
+ * an assumed-cooked string would be error-prone.
+ *
+ *
This field is optional.
+ *
+ * @param query the new query component, or null to clear this field
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setRawQuery(@Nullable String query) {
+ if (query != null) {
+ checkPercentEncodedArg(query, "query", queryChars);
+ }
+ this.query = query;
+ return this;
+ }
+
+ /**
+ * Specifies the fragment component of the new URI (not including the leading '#').
+ *
+ *
The fragment can contain any string of codepoints. Codepoints that can't be encoded
+ * literally will be percent-encoded for you as UTF-8.
+ *
+ *
NB: Choose carefully between this method and {@link #setRawFragment(String)}. Many URI
+ * schemes embed further structure in the fragment that isn't part of the RFC 3986 generic
+ * syntax. These schemes often use internal delimiters that must be carefully percent-encoded in
+ * ways that this method doesn't understand. See {@link #getFragment()} for an example. In that
+ * case, callers should percent-encode externally then call {@link #setRawFragment(String)}
+ * instead.
+ *
+ *
This field is optional.
+ *
+ * @param fragment the new fragment component, or null to clear this field
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setFragment(@Nullable String fragment) {
+ this.fragment = percentEncode(fragment, fragmentChars);
+ return this;
+ }
+
+ /**
+ * Specifies the fragment component of the new URI, already percent-encoded, exactly as it will
+ * appear after the '#' delimiter in the string form of the built URI.
+ *
+ *
NB: Choose carefully between this method and {@link #setFragment(String)}. {@code
+ * fragment} must only contain codepoints from RFC 3986's "fragment" character class. Use
+ * percent-encoding and UTF-8 to represent anything else. In certain cases, you can use {@link
+ * #setFragment(String)} to have the fragment percent-encoded for you instead, but see that
+ * method's Javadoc for its limitations.
+ *
+ *
This field is optional.
+ *
+ * @param fragment the new fragment component, or null to clear this field
+ * @return this, for fluent building
+ * @throws IllegalArgumentException if 'fragment' contains forbidden characters
+ */
+ @CanIgnoreReturnValue
+ public Builder setRawFragment(@Nullable String fragment) {
+ if (fragment != null) {
+ checkPercentEncodedArg(fragment, "fragment", fragmentChars);
+ }
+ this.fragment = fragment;
+ return this;
+ }
+
+ /**
+ * Set the "user info" component of the new URI, e.g. "username:password", not including the
+ * trailing '@' character.
+ *
+ *
User info can contain any string of codepoints. Codepoints that can't be encoded literally
+ * will be percent-encoded for you as UTF-8.
+ *
+ *
This field is optional.
+ *
+ * @param userInfo the new "user info" component, or null to clear this field
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setUserInfo(@Nullable String userInfo) {
+ this.userInfo = percentEncode(userInfo, userInfoChars);
+ return this;
+ }
+
+ @CanIgnoreReturnValue
+ Builder setRawUserInfo(String userInfo) {
+ checkPercentEncodedArg(userInfo, "userInfo", userInfoChars);
+ this.userInfo = userInfo;
+ return this;
+ }
+
+ /**
+ * Specifies the "host" component of the new URI in its "registered name" form (usually DNS),
+ * e.g. "server.com".
+ *
+ *
The registered name can contain any string of codepoints. Codepoints that can't be encoded
+ * literally will be percent-encoded for you as UTF-8.
+ *
+ *
This field is optional.
+ *
+ * @param regName the new host component in "registered name" form, or null to clear this field
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setHost(@Nullable String regName) {
+ if (regName != null) {
+ regName = regName.toLowerCase(Locale.ROOT);
+ regName = percentEncode(regName, regNameChars);
+ }
+ this.host = regName;
+ return this;
+ }
+
+ /**
+ * Specifies the "host" component of the new URI as an IP address.
+ *
+ *
This field is optional.
+ *
+ * @param addr the new "host" component in InetAddress form, or null to clear this field
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setHost(@Nullable InetAddress addr) {
+ this.host = addr != null ? toUriString(addr) : null;
+ return this;
+ }
+
+ private static String toUriString(InetAddress addr) {
+ // InetAddresses.toUriString(addr) is almost enough but neglects RFC 6874 percent encoding.
+ String inetAddrStr = InetAddresses.toUriString(addr);
+ int percentIndex = inetAddrStr.indexOf('%');
+ if (percentIndex < 0) {
+ return inetAddrStr;
+ }
+
+ String scope = inetAddrStr.substring(percentIndex, inetAddrStr.length() - 1);
+ return inetAddrStr.substring(0, percentIndex) + percentEncode(scope, unreservedChars) + "]";
+ }
+
+ @CanIgnoreReturnValue
+ Builder setRawHost(String host) {
+ if (host.startsWith("[") && host.endsWith("]")) {
+ // IP-literal: Guava's isUriInetAddress() is almost enough but it doesn't check the scope.
+ int percentIndex = host.indexOf('%');
+ if (percentIndex > 0) {
+ String scope = host.substring(percentIndex, host.length() - 1);
+ checkPercentEncodedArg(scope, "scope", unreservedChars);
+ }
+ }
+ // IP-literal validation is complicated so we delegate it to Guava. We use this particular
+ // method of InetAddresses because it doesn't try to match interfaces on the local machine.
+ // (The validity of a URI should be the same no matter which machine does the parsing.)
+ // TODO(jdcormie): IPFuture
+ if (!InetAddresses.isUriInetAddress(host)) {
+ // Must be a "registered name".
+ checkPercentEncodedArg(host, "host", regNameChars);
+ }
+ this.host = host;
+ return this;
+ }
+
+ /**
+ * Specifies the "port" component of the new URI, e.g. "8080".
+ *
+ *
The port can be any non-negative integer. A negative value represents "no port".
+ *
+ *
This field is optional.
+ *
+ * @param port the new "port" component, or -1 to clear this field
+ * @return this, for fluent building
+ */
+ @CanIgnoreReturnValue
+ public Builder setPort(int port) {
+ this.port = port < 0 ? null : Integer.toString(port);
+ return this;
+ }
+
+ @CanIgnoreReturnValue
+ Builder setRawPort(String port) {
+ if (port != null && !port.isEmpty()) {
+ try {
+ Integer.parseInt(port); // Result unused.
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("Invalid port", e);
+ }
+ }
+ this.port = port;
+ return this;
+ }
+
+ /**
+ * Specifies the userinfo, host and port URI components all at once using a single string.
+ *
+ *
This setter is "raw" in the sense that special characters in userinfo and host must be
+ * passed in percent-encoded. See RFC 3986 3.2 for the set
+ * of characters allowed in each component of an authority.
+ *
+ *
There's no "cooked" method to set authority like for other URI components because
+ * authority is a *compound* URI component whose userinfo, host and port components are
+ * delimited with special characters '@' and ':'. But the first two of those components can
+ * themselves contain these delimiters so we need percent-encoding to parse them unambiguously.
+ *
+ * @param authority an RFC 3986 authority string that will be used to set userinfo, host and
+ * port, or null to clear all three of those components
+ */
+ @CanIgnoreReturnValue
+ public Builder setRawAuthority(@Nullable String authority) {
+ if (authority == null) {
+ setUserInfo(null);
+ setHost((String) null);
+ setPort(-1);
+ } else {
+ // UserInfo. Easy because '@' cannot appear unencoded inside userinfo or host.
+ int userInfoEnd = authority.indexOf('@');
+ if (userInfoEnd >= 0) {
+ setRawUserInfo(authority.substring(0, userInfoEnd));
+ } else {
+ setUserInfo(null);
+ }
+
+ // Host/Port.
+ int hostStart = userInfoEnd >= 0 ? userInfoEnd + 1 : 0;
+ int portStartColon = findPortStartColon(authority, hostStart);
+ if (portStartColon < 0) {
+ setRawHost(authority.substring(hostStart));
+ setPort(-1);
+ } else {
+ setRawHost(authority.substring(hostStart, portStartColon));
+ setRawPort(authority.substring(portStartColon + 1));
+ }
+ }
+ return this;
+ }
+
+ /** Builds a new instance of {@link Uri} as specified by the setters. */
+ public Uri build() {
+ checkState(scheme != null, "Missing required scheme.");
+ if (host == null) {
+ checkState(port == null, "Cannot set port without host.");
+ checkState(userInfo == null, "Cannot set userInfo without host.");
+ }
+ return new Uri(this);
+ }
+ }
+
+ /**
+ * Decodes a string of characters in the range [U+0000, U+007F] to bytes.
+ *
+ *
Each percent-encoded sequence (e.g. "%F0" or "%2a", as defined by RFC 3986 2.1) is decoded
+ * to the octet it encodes. Other characters are decoded to their code point's single byte value.
+ * A literal % character must be encoded as %25.
+ *
+ * @throws IllegalArgumentException if 's' contains characters out of range or invalid percent
+ * encoding sequences.
+ */
+ public static ByteBuffer percentDecode(CharSequence s) {
+ // This is large enough because each input character needs *at most* one byte of output.
+ ByteBuffer outBuf = ByteBuffer.allocate(s.length());
+ percentDecode(s, "input", null, outBuf);
+ outBuf.flip();
+ return outBuf;
+ }
+
+ private static void percentDecode(
+ CharSequence s, String what, BitSet allowedChars, ByteBuffer outBuf) {
+ for (int i = 0; i < s.length(); i++) {
+ char c = s.charAt(i);
+ if (c == '%') {
+ if (i + 2 >= s.length()) {
+ throw new IllegalArgumentException(
+ "Invalid percent-encoding at index " + i + " of " + what + ": " + s);
+ }
+ int h1 = Character.digit(s.charAt(i + 1), 16);
+ int h2 = Character.digit(s.charAt(i + 2), 16);
+ if (h1 == -1 || h2 == -1) {
+ throw new IllegalArgumentException(
+ "Invalid hex digit in " + what + " at index " + i + " of: " + s);
+ }
+ if (outBuf != null) {
+ outBuf.put((byte) (h1 << 4 | h2));
+ }
+ i += 2;
+ } else if (allowedChars == null || allowedChars.get(c)) {
+ if (outBuf != null) {
+ outBuf.put((byte) c);
+ }
+ } else {
+ throw new IllegalArgumentException("Invalid character in " + what + " at index " + i);
+ }
+ }
+ }
+
+ @Nullable
+ private static String percentDecodeAssumedUtf8(@Nullable String s) {
+ if (s == null || s.indexOf('%') == -1) {
+ return s;
+ }
+
+ ByteBuffer utf8Bytes = percentDecode(s);
+ try {
+ return StandardCharsets.UTF_8
+ .newDecoder()
+ .onMalformedInput(CodingErrorAction.REPLACE)
+ .onUnmappableCharacter(CodingErrorAction.REPLACE)
+ .decode(utf8Bytes)
+ .toString();
+ } catch (CharacterCodingException e) {
+ throw new VerifyException(e); // Should not happen in REPLACE mode.
+ }
+ }
+
+ @Nullable
+ private static String percentEncode(String s, BitSet allowedCodePoints) {
+ if (s == null) {
+ return null;
+ }
+ CharsetEncoder encoder =
+ StandardCharsets.UTF_8
+ .newEncoder()
+ .onMalformedInput(CodingErrorAction.REPORT)
+ .onUnmappableCharacter(CodingErrorAction.REPORT);
+ ByteBuffer utf8Bytes;
+ try {
+ utf8Bytes = encoder.encode(CharBuffer.wrap(s));
+ } catch (MalformedInputException e) {
+ throw new IllegalArgumentException("Malformed input", e); // Must be a broken surrogate pair.
+ } catch (CharacterCodingException e) {
+ throw new VerifyException(e); // Should not happen when encoding to UTF-8.
+ }
+
+ StringBuilder sb = new StringBuilder();
+ while (utf8Bytes.hasRemaining()) {
+ int b = 0xff & utf8Bytes.get();
+ if (allowedCodePoints.get(b)) {
+ sb.append((char) b);
+ } else {
+ sb.append('%');
+ sb.append(hexDigitsByVal[(b & 0xF0) >> 4]);
+ sb.append(hexDigitsByVal[b & 0x0F]);
+ }
+ }
+ return sb.toString();
+ }
+
+ private static void checkPercentEncodedArg(String s, String what, BitSet allowedChars) {
+ percentDecode(s, what, allowedChars, null);
+ }
+
+ // See UriTest for how these were computed from the ABNF constants in RFC 3986.
+ static final BitSet digitChars = BitSet.valueOf(new long[] {0x3ff000000000000L});
+ static final BitSet alphaChars = BitSet.valueOf(new long[] {0L, 0x7fffffe07fffffeL});
+ // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+ static final BitSet schemeChars =
+ BitSet.valueOf(new long[] {0x3ff680000000000L, 0x7fffffe07fffffeL});
+ // unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ static final BitSet unreservedChars =
+ BitSet.valueOf(new long[] {0x3ff600000000000L, 0x47fffffe87fffffeL});
+ // gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+ static final BitSet genDelimsChars =
+ BitSet.valueOf(new long[] {0x8400800800000000L, 0x28000001L});
+ // sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ static final BitSet subDelimsChars = BitSet.valueOf(new long[] {0x28001fd200000000L});
+ // reserved = gen-delims / sub-delims
+ static final BitSet reservedChars = BitSet.valueOf(new long[] {0xac009fda00000000L, 0x28000001L});
+ // reg-name = *( unreserved / pct-encoded / sub-delims )
+ static final BitSet regNameChars =
+ BitSet.valueOf(new long[] {0x2bff7fd200000000L, 0x47fffffe87fffffeL});
+ // userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
+ static final BitSet userInfoChars =
+ BitSet.valueOf(new long[] {0x2fff7fd200000000L, 0x47fffffe87fffffeL});
+ // pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
+ static final BitSet pChars =
+ BitSet.valueOf(new long[] {0x2fff7fd200000000L, 0x47fffffe87ffffffL});
+ static final BitSet pCharsAndSlash =
+ BitSet.valueOf(new long[] {0x2fffffd200000000L, 0x47fffffe87ffffffL});
+ // query = *( pchar / "/" / "?" )
+ static final BitSet queryChars =
+ BitSet.valueOf(new long[] {0xafffffd200000000L, 0x47fffffe87ffffffL});
+ // fragment = *( pchar / "/" / "?" )
+ static final BitSet fragmentChars = queryChars;
+
+ private static final char[] hexDigitsByVal = "0123456789ABCDEF".toCharArray();
+}
diff --git a/api/src/test/java/io/grpc/HttpConnectProxiedSocketAddressTest.java b/api/src/test/java/io/grpc/HttpConnectProxiedSocketAddressTest.java
new file mode 100644
index 00000000000..6620a7d413a
--- /dev/null
+++ b/api/src/test/java/io/grpc/HttpConnectProxiedSocketAddressTest.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2025 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.testing.EqualsTester;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HttpConnectProxiedSocketAddressTest {
+
+ private final InetSocketAddress proxyAddress =
+ new InetSocketAddress(InetAddress.getLoopbackAddress(), 8080);
+ private final InetSocketAddress targetAddress =
+ InetSocketAddress.createUnresolved("example.com", 443);
+
+ @Test
+ public void buildWithAllFields() {
+ Map headers = new HashMap<>();
+ headers.put("X-Custom-Header", "custom-value");
+ headers.put("Proxy-Authorization", "Bearer token");
+
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers)
+ .setUsername("user")
+ .setPassword("pass")
+ .build();
+
+ assertThat(address.getProxyAddress()).isEqualTo(proxyAddress);
+ assertThat(address.getTargetAddress()).isEqualTo(targetAddress);
+ assertThat(address.getHeaders()).hasSize(2);
+ assertThat(address.getHeaders()).containsEntry("X-Custom-Header", "custom-value");
+ assertThat(address.getHeaders()).containsEntry("Proxy-Authorization", "Bearer token");
+ assertThat(address.getUsername()).isEqualTo("user");
+ assertThat(address.getPassword()).isEqualTo("pass");
+ }
+
+ @Test
+ public void buildWithoutOptionalFields() {
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .build();
+
+ assertThat(address.getProxyAddress()).isEqualTo(proxyAddress);
+ assertThat(address.getTargetAddress()).isEqualTo(targetAddress);
+ assertThat(address.getHeaders()).isEmpty();
+ assertThat(address.getUsername()).isNull();
+ assertThat(address.getPassword()).isNull();
+ }
+
+ @Test
+ public void buildWithEmptyHeaders() {
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(Collections.emptyMap())
+ .build();
+
+ assertThat(address.getHeaders()).isEmpty();
+ }
+
+ @Test
+ public void headersAreImmutable() {
+ Map headers = new HashMap<>();
+ headers.put("key1", "value1");
+
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers)
+ .build();
+
+ headers.put("key2", "value2");
+
+ assertThat(address.getHeaders()).hasSize(1);
+ assertThat(address.getHeaders()).containsEntry("key1", "value1");
+ assertThat(address.getHeaders()).doesNotContainKey("key2");
+ }
+
+ @Test
+ public void returnedHeadersAreUnmodifiable() {
+ Map headers = new HashMap<>();
+ headers.put("key", "value");
+
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers)
+ .build();
+
+ assertThrows(UnsupportedOperationException.class,
+ () -> address.getHeaders().put("newKey", "newValue"));
+ }
+
+ @Test
+ public void nullHeadersThrowsException() {
+ assertThrows(NullPointerException.class,
+ () -> HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(null)
+ .build());
+ }
+
+ @Test
+ public void equalsAndHashCode() {
+ Map headers1 = new HashMap<>();
+ headers1.put("header", "value");
+
+ Map headers2 = new HashMap<>();
+ headers2.put("header", "value");
+
+ Map differentHeaders = new HashMap<>();
+ differentHeaders.put("different", "header");
+
+ new EqualsTester()
+ .addEqualityGroup(
+ HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers1)
+ .setUsername("user")
+ .setPassword("pass")
+ .build(),
+ HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers2)
+ .setUsername("user")
+ .setPassword("pass")
+ .build())
+ .addEqualityGroup(
+ HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(differentHeaders)
+ .setUsername("user")
+ .setPassword("pass")
+ .build())
+ .addEqualityGroup(
+ HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .build())
+ .testEquals();
+ }
+
+ @Test
+ public void toStringContainsHeaders() {
+ Map headers = new HashMap<>();
+ headers.put("X-Test", "test-value");
+
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers)
+ .setUsername("user")
+ .setPassword("secret")
+ .build();
+
+ String toString = address.toString();
+ assertThat(toString).contains("headers");
+ assertThat(toString).contains("X-Test");
+ assertThat(toString).contains("hasPassword=true");
+ assertThat(toString).doesNotContain("secret");
+ }
+
+ @Test
+ public void toStringWithoutPassword() {
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .build();
+
+ String toString = address.toString();
+ assertThat(toString).contains("hasPassword=false");
+ }
+
+ @Test
+ public void hashCodeDependsOnHeaders() {
+ Map headers1 = new HashMap<>();
+ headers1.put("header", "value1");
+
+ Map headers2 = new HashMap<>();
+ headers2.put("header", "value2");
+
+ HttpConnectProxiedSocketAddress address1 = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers1)
+ .build();
+
+ HttpConnectProxiedSocketAddress address2 = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers2)
+ .build();
+
+ assertNotEquals(address1.hashCode(), address2.hashCode());
+ }
+
+ @Test
+ public void multipleHeadersSupported() {
+ Map headers = new HashMap<>();
+ headers.put("X-Header-1", "value1");
+ headers.put("X-Header-2", "value2");
+ headers.put("X-Header-3", "value3");
+
+ HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+ .setProxyAddress(proxyAddress)
+ .setTargetAddress(targetAddress)
+ .setHeaders(headers)
+ .build();
+
+ assertThat(address.getHeaders()).hasSize(3);
+ assertThat(address.getHeaders()).containsEntry("X-Header-1", "value1");
+ assertThat(address.getHeaders()).containsEntry("X-Header-2", "value2");
+ assertThat(address.getHeaders()).containsEntry("X-Header-3", "value3");
+ }
+}
+
diff --git a/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java b/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
index 5b348b7adab..690db6622e0 100644
--- a/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
+++ b/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
@@ -40,7 +40,7 @@ public void getClassesViaHardcoded_classesPresent() throws Exception {
@Test
public void stockProviders() {
LoadBalancerRegistry defaultRegistry = LoadBalancerRegistry.getDefaultRegistry();
- assertThat(defaultRegistry.providers()).hasSize(3);
+ assertThat(defaultRegistry.providers()).hasSize(4);
LoadBalancerProvider pickFirst = defaultRegistry.getProvider("pick_first");
assertThat(pickFirst).isInstanceOf(PickFirstLoadBalancerProvider.class);
@@ -56,6 +56,12 @@ public void stockProviders() {
assertThat(outlierDetection.getClass().getName()).isEqualTo(
"io.grpc.util.OutlierDetectionLoadBalancerProvider");
assertThat(roundRobin.getPriority()).isEqualTo(5);
+
+ LoadBalancerProvider randomSubsetting = defaultRegistry.getProvider(
+ "random_subsetting_experimental");
+ assertThat(randomSubsetting.getClass().getName()).isEqualTo(
+ "io.grpc.util.RandomSubsettingLoadBalancerProvider");
+ assertThat(randomSubsetting.getPriority()).isEqualTo(5);
}
@Test
diff --git a/api/src/test/java/io/grpc/LoadBalancerTest.java b/api/src/test/java/io/grpc/LoadBalancerTest.java
index 5e9e5cbe816..22fdc220081 100644
--- a/api/src/test/java/io/grpc/LoadBalancerTest.java
+++ b/api/src/test/java/io/grpc/LoadBalancerTest.java
@@ -64,6 +64,26 @@ public void pickResult_withSubchannelAndTracer() {
assertThat(result.isDrop()).isFalse();
}
+ @Test
+ public void pickResult_withSubchannelReplacement() {
+ PickResult result = PickResult.withSubchannel(subchannel, tracerFactory)
+ .copyWithSubchannel(subchannel2);
+ assertThat(result.getSubchannel()).isSameInstanceAs(subchannel2);
+ assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
+ assertThat(result.getStreamTracerFactory()).isSameInstanceAs(tracerFactory);
+ assertThat(result.isDrop()).isFalse();
+ }
+
+ @Test
+ public void pickResult_withStreamTracerFactory() {
+ PickResult result = PickResult.withSubchannel(subchannel)
+ .copyWithStreamTracerFactory(tracerFactory);
+ assertThat(result.getSubchannel()).isSameInstanceAs(subchannel);
+ assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
+ assertThat(result.getStreamTracerFactory()).isSameInstanceAs(tracerFactory);
+ assertThat(result.isDrop()).isFalse();
+ }
+
@Test
public void pickResult_withNoResult() {
PickResult result = PickResult.withNoResult();
diff --git a/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java b/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
index 30de2477d77..7b02459290e 100644
--- a/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
+++ b/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
@@ -20,17 +20,23 @@
import static org.junit.Assert.fail;
import com.google.common.collect.ImmutableSet;
+import io.grpc.FlagResetRule;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.URI;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
+import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
/** Unit tests for {@link ManagedChannelRegistry}. */
-@RunWith(JUnit4.class)
+@RunWith(Parameterized.class)
public class ManagedChannelRegistryTest {
private String target = "testing123";
private ChannelCredentials creds = new ChannelCredentials() {
@@ -40,6 +46,20 @@ public ChannelCredentials withoutBearerTokens() {
}
};
+ @Rule public final FlagResetRule flagResetRule = new FlagResetRule();
+
+ @Parameters(name = "enableRfc3986UrisParam={0}")
+ public static Iterable data() {
+ return Arrays.asList(new Object[][] {{true}, {false}});
+ }
+
+ @Parameter public boolean enableRfc3986UrisParam;
+
+ @Before
+ public void setUp() {
+ flagResetRule.setFlagForTest(FeatureFlags::setRfc3986UrisEnabled, enableRfc3986UrisParam);
+ }
+
@Test
public void register_unavailableProviderThrows() {
ManagedChannelRegistry reg = new ManagedChannelRegistry();
@@ -223,6 +243,53 @@ public NewChannelBuilderResult newChannelBuilder(
mcb);
}
+ @Test
+ public void newChannelBuilder_propagatesRegistry() {
+ final NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+ class SocketAddress1 extends SocketAddress {
+ }
+
+ ManagedChannelRegistry registry = new ManagedChannelRegistry();
+ class MockChannelBuilder extends ForwardingChannelBuilder2 {
+ @Override
+ public ManagedChannelBuilder delegate() {
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ final ManagedChannelBuilder mcb = new MockChannelBuilder();
+ registry.register(new BaseProvider(true, 4) {
+ @Override
+ protected Collection> getSupportedSocketAddressTypes() {
+ return Collections.singleton(SocketAddress1.class);
+ }
+
+ @Override
+ public NewChannelBuilderResult newChannelBuilder(
+ String passedTarget, ChannelCredentials passedCreds,
+ NameResolverRegistry passedRegistry, NameResolverProvider passedProvider) {
+ assertThat(passedRegistry).isSameInstanceAs(nameResolverRegistry);
+ return NewChannelBuilderResult.channelBuilder(mcb);
+ }
+ });
+
+ // ManagedChannelRegistry.newChannelBuilder(NameResolverRegistry, String, ChannelCredentials)
+ // gets the scheme from target. Then it gets NameResolverProvider from registry for that scheme.
+ // Then it gets producedSocketAddressTypes from that provider.
+ // Then it finds a ManagedChannelProvider that supports those types.
+ // So we need a registered NameResolverProvider for the scheme.
+ nameResolverRegistry.register(new BaseNameResolverProvider(true, 5, "sc1") {
+ @Override
+ public Collection> getProducedSocketAddressTypes() {
+ return Collections.singleton(SocketAddress1.class);
+ }
+ });
+
+ assertThat(
+ registry.newChannelBuilder(nameResolverRegistry, "sc1:" + target, creds)).isSameInstanceAs(
+ mcb);
+ }
+
@Test
public void newChannelBuilder_unsupportedSocketAddressTypes() {
NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
diff --git a/api/src/test/java/io/grpc/NameResolverRegistryTest.java b/api/src/test/java/io/grpc/NameResolverRegistryTest.java
index 2fd23e3a974..76976c3b59b 100644
--- a/api/src/test/java/io/grpc/NameResolverRegistryTest.java
+++ b/api/src/test/java/io/grpc/NameResolverRegistryTest.java
@@ -33,7 +33,8 @@
/** Unit tests for {@link NameResolverRegistry}. */
@RunWith(JUnit4.class)
public class NameResolverRegistryTest {
- private final URI uri = URI.create("dns:///localhost");
+ private final URI javaNetUri = URI.create("dns:///localhost");
+ private final Uri ioGrpcUri = Uri.create("dns:///localhost");
private final NameResolver.Args args = NameResolver.Args.newBuilder()
.setDefaultPort(8080)
.setProxyDetector(mock(ProxyDetector.class))
@@ -96,43 +97,80 @@ public void getDefaultScheme_noProvider() {
}
@Test
- public void newNameResolver_providerReturnsNull() {
+ public void newNameResolver_providerReturnsNull_ioGrpcUri() {
NameResolverRegistry registry = new NameResolverRegistry();
registry.register(
- new BaseProvider(true, 5, "noScheme") {
+ new BaseProvider(true, 5, ioGrpcUri.getScheme()) {
@Override
- public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
- assertThat(passedUri).isSameInstanceAs(uri);
+ public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+ assertThat(passedUri).isSameInstanceAs(ioGrpcUri);
assertThat(passedArgs).isSameInstanceAs(args);
return null;
}
});
- assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
- assertThat(registry.asFactory().getDefaultScheme()).isEqualTo("noScheme");
+ assertThat(registry.asFactory().newNameResolver(ioGrpcUri, args)).isNull();
+ assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(ioGrpcUri.getScheme());
}
@Test
- public void newNameResolver_providerReturnsNonNull() {
+ public void newNameResolver_providerReturnsNull_javaNetUri() {
NameResolverRegistry registry = new NameResolverRegistry();
- registry.register(new BaseProvider(true, 5, uri.getScheme()) {
- @Override
- public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
- return null;
- }
- });
- final NameResolver nr = new NameResolver() {
- @Override public String getServiceAuthority() {
- throw new UnsupportedOperationException();
- }
+ registry.register(
+ new BaseProvider(true, 5, javaNetUri.getScheme()) {
+ @Override
+ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+ assertThat(passedUri).isSameInstanceAs(javaNetUri);
+ assertThat(passedArgs).isSameInstanceAs(args);
+ return null;
+ }
+ });
+ assertThat(registry.asFactory().newNameResolver(javaNetUri, args)).isNull();
+ assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(javaNetUri.getScheme());
+ }
- @Override public void start(Listener2 listener) {
- throw new UnsupportedOperationException();
- }
+ @Test
+ public void newNameResolver_providerReturnsNonNull_ioGrpcUri() {
+ NameResolverRegistry registry = new NameResolverRegistry();
+ Uri uri = ioGrpcUri;
+ registry.register(
+ new BaseProvider(true, 5, uri.getScheme()) {
+ @Override
+ public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+ return null;
+ }
+ });
+ final NameResolver nr = new DummyNameResolver();
+ registry.register(
+ new BaseProvider(true, 4, uri.getScheme()) {
+ @Override
+ public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+ return nr;
+ }
+ });
+ registry.register(
+ new BaseProvider(true, 3, uri.getScheme()) {
+ @Override
+ public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+ fail("Should not be called");
+ throw new AssertionError();
+ }
+ });
+ assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
+ assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(uri.getScheme());
+ }
- @Override public void shutdown() {
- throw new UnsupportedOperationException();
- }
- };
+ @Test
+ public void newNameResolver_providerReturnsNonNull_javaNetUri() {
+ NameResolverRegistry registry = new NameResolverRegistry();
+ URI uri = javaNetUri;
+ registry.register(
+ new BaseProvider(true, 5, uri.getScheme()) {
+ @Override
+ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+ return null;
+ }
+ });
+ final NameResolver nr = new DummyNameResolver();
registry.register(
new BaseProvider(true, 4, uri.getScheme()) {
@Override
@@ -153,27 +191,45 @@ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs)
}
@Test
- public void newNameResolver_multipleScheme() {
+ public void newNameResolver_multipleScheme_ioGrpcUri() {
NameResolverRegistry registry = new NameResolverRegistry();
- registry.register(new BaseProvider(true, 5, uri.getScheme()) {
- @Override
- public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
- return null;
- }
- });
- final NameResolver nr = new NameResolver() {
- @Override public String getServiceAuthority() {
- throw new UnsupportedOperationException();
- }
+ Uri uri = ioGrpcUri;
+ registry.register(
+ new BaseProvider(true, 5, uri.getScheme()) {
+ @Override
+ public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+ return null;
+ }
+ });
+ final NameResolver nr = new DummyNameResolver();
+ registry.register(
+ new BaseProvider(true, 4, "other") {
+ @Override
+ public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+ return nr;
+ }
+ });
- @Override public void start(Listener2 listener) {
- throw new UnsupportedOperationException();
- }
+ assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
+ assertThat(registry.asFactory().newNameResolver(Uri.create("other:///0.0.0.0:80"), args))
+ .isSameInstanceAs(nr);
+ assertThat(registry.asFactory().newNameResolver(Uri.create("OTHER:///0.0.0.0:80"), args))
+ .isSameInstanceAs(nr);
+ assertThat(registry.asFactory().getDefaultScheme()).isEqualTo("dns");
+ }
- @Override public void shutdown() {
- throw new UnsupportedOperationException();
- }
- };
+ @Test
+ public void newNameResolver_multipleScheme_javaNetUri() {
+ NameResolverRegistry registry = new NameResolverRegistry();
+ URI uri = javaNetUri;
+ registry.register(
+ new BaseProvider(true, 5, uri.getScheme()) {
+ @Override
+ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+ return null;
+ }
+ });
+ final NameResolver nr = new DummyNameResolver();
registry.register(
new BaseProvider(true, 4, "other") {
@Override
@@ -186,16 +242,17 @@ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs)
assertThat(registry.asFactory().newNameResolver(URI.create("/0.0.0.0:80"), args)).isNull();
assertThat(registry.asFactory().newNameResolver(URI.create("///0.0.0.0:80"), args)).isNull();
assertThat(registry.asFactory().newNameResolver(URI.create("other:///0.0.0.0:80"), args))
- .isSameInstanceAs(nr);
+ .isSameInstanceAs(nr);
assertThat(registry.asFactory().newNameResolver(URI.create("OTHER:///0.0.0.0:80"), args))
- .isSameInstanceAs(nr);
+ .isSameInstanceAs(nr);
assertThat(registry.asFactory().getDefaultScheme()).isEqualTo("dns");
}
@Test
public void newNameResolver_noProvider() {
NameResolver.Factory factory = new NameResolverRegistry().asFactory();
- assertThat(factory.newNameResolver(uri, args)).isNull();
+ assertThat(factory.newNameResolver(javaNetUri, args)).isNull();
+ assertThat(factory.newNameResolver(ioGrpcUri, args)).isNull();
assertThat(factory.getDefaultScheme()).isEqualTo("unknown");
}
@@ -261,9 +318,31 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
throw new UnsupportedOperationException();
}
+ @Override
+ public NameResolver newNameResolver(Uri targetUri, NameResolver.Args args) {
+ throw new UnsupportedOperationException();
+ }
+
@Override
public String getDefaultScheme() {
return scheme == null ? "scheme" + getClass().getSimpleName() : scheme;
}
}
+
+ private static class DummyNameResolver extends NameResolver {
+ @Override
+ public String getServiceAuthority() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void start(Listener2 listener) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void shutdown() {
+ throw new UnsupportedOperationException();
+ }
+ }
}
diff --git a/api/src/test/java/io/grpc/NameResolverTest.java b/api/src/test/java/io/grpc/NameResolverTest.java
index ae8c080bd5c..82abe5c7505 100644
--- a/api/src/test/java/io/grpc/NameResolverTest.java
+++ b/api/src/test/java/io/grpc/NameResolverTest.java
@@ -192,6 +192,56 @@ public void resolutionResult_hashCode() {
Objects.hashCode(StatusOr.fromValue(ADDRESSES), ATTRIBUTES, CONFIG));
}
+ @Test
+ public void startOnOldListener_resolverReportsError() {
+ final boolean[] onErrorCalled = new boolean[1];
+ final Status[] receivedError = new Status[1];
+
+ NameResolver resolver = new NameResolver() {
+ @Override
+ public String getServiceAuthority() {
+ return "example.com";
+ }
+
+ @Override
+ public void shutdown() {
+ }
+
+ @Override
+ public void start(Listener2 listener2) {
+ ResolutionResult errorResult = ResolutionResult.newBuilder()
+ .setAddressesOrError(StatusOr.fromStatus(
+ Status.UNAVAILABLE
+ .withDescription("DNS resolution failed with UNAVAILABLE")))
+ .build();
+
+ listener2.onResult(errorResult);
+ }
+ };
+
+ NameResolver.Listener listener = new NameResolver.Listener() {
+ @Override
+ public void onAddresses(
+ List servers,
+ Attributes attributes) {
+ throw new AssertionError("Called onAddresses on error");
+ }
+
+ @Override
+ public void onError(Status error) {
+ onErrorCalled[0] = true;
+ receivedError[0] = error;
+ }
+ };
+
+ resolver.start(listener);
+
+ assertThat(onErrorCalled[0]).isTrue();
+ assertThat(receivedError[0].getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+ assertThat(receivedError[0].getDescription()).isEqualTo(
+ "DNS resolution failed with UNAVAILABLE");
+ }
+
private static class FakeSocketAddress extends SocketAddress {
final String name;
diff --git a/api/src/test/java/io/grpc/QueryParamsTest.java b/api/src/test/java/io/grpc/QueryParamsTest.java
new file mode 100644
index 00000000000..2def165a170
--- /dev/null
+++ b/api/src/test/java/io/grpc/QueryParamsTest.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import io.grpc.QueryParams.Entry;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link QueryParams}. */
+@RunWith(JUnit4.class)
+public class QueryParamsTest {
+
+ @Test
+ public void emptyInstance() {
+ QueryParams params = new QueryParams();
+ assertThat(params.asList()).isEmpty();
+ assertThat(params.toRawQuery()).isNull();
+ }
+
+ @Test
+ public void parseNull_yieldsEmptyInstance() {
+ QueryParams params = QueryParams.fromRawQuery(null);
+ assertThat(params.asList()).isEmpty();
+ assertThat(params.toRawQuery()).isNull();
+ }
+
+ @Test
+ public void parseEmptyString_yieldsSingleLoneKey() {
+ QueryParams params = QueryParams.fromRawQuery("");
+ assertThat(params.toRawQuery()).isEmpty();
+ assertThat(params.asList()).isNotEmpty();
+ Entry entry = params.asList().get(0);
+ assertThat(entry).isNotNull();
+ assertThat(entry.getKey()).isEmpty();
+ assertThat(entry.hasValue()).isFalse();
+ assertThat(entry.getValue()).isNull();
+ }
+
+ @Test
+ public void parseNormalPairs() {
+ QueryParams params = QueryParams.fromRawQuery("a=b&c=d");
+ assertThat(params.toRawQuery()).isEqualTo("a=b&c=d");
+
+ QueryParams.Entry a = params.asList().get(0);
+ assertThat(a.getKey()).isEqualTo("a");
+ assertThat(a.hasValue()).isTrue();
+ assertThat(a.getValue()).isEqualTo("b");
+
+ QueryParams.Entry c = params.asList().get(1);
+ assertThat(c.getKey()).isEqualTo("c");
+ assertThat(c.getValue()).isEqualTo("d");
+ }
+
+ @Test
+ public void parseLoneKey() {
+ QueryParams params = QueryParams.fromRawQuery("a&b");
+ assertThat(params.toRawQuery()).isEqualTo("a&b");
+
+ QueryParams.Entry a = params.asList().get(0);
+ assertThat(a.getKey()).isEqualTo("a");
+ assertThat(a.hasValue()).isFalse();
+
+ QueryParams.Entry b = params.asList().get(1);
+ assertThat(b.getKey()).isEqualTo("b");
+ assertThat(b.hasValue()).isFalse();
+ }
+
+ @Test
+ public void parseEmptyKeysAndValues() {
+ QueryParams params = QueryParams.fromRawQuery("=&=");
+ assertThat(params.toRawQuery()).isEqualTo("=&=");
+
+ assertThat(params.asList()).hasSize(2);
+ assertThat(params.asList().get(0).getKey()).isEmpty();
+ assertThat(params.asList().get(0).hasValue()).isTrue();
+ assertThat(params.asList().get(0).getValue()).isEmpty();
+ assertThat(params.asList().get(1).getKey()).isEmpty();
+ assertThat(params.asList().get(1).hasValue()).isTrue();
+ assertThat(params.asList().get(1).getValue()).isEmpty();
+ }
+
+ @Test
+ public void roundTripPreservesEncodingOfSpaces() {
+ // Spaces can be encoded as + or %20.
+ QueryParams params = QueryParams.fromRawQuery("a+b=c%20d");
+ assertThat(params.asList().get(0).getKey()).isEqualTo("a b");
+ assertThat(params.asList().get(0).getValue()).isEqualTo("c d");
+ assertThat(params.toRawQuery()).isEqualTo("a+b=c%20d");
+ }
+
+ @Test
+ public void roundTripPreservesCaseOfHexDigits() {
+ // Percent encoding can use upper or lower case.
+ QueryParams params = QueryParams.fromRawQuery("%4A%4a=%4B%4b");
+ assertThat(params.asList().get(0).getKey()).isEqualTo("JJ");
+ assertThat(params.asList().get(0).getValue()).isEqualTo("KK");
+ assertThat(params.toRawQuery()).isEqualTo("%4A%4a=%4B%4b");
+ }
+
+ @Test
+ public void asListMethod() {
+ QueryParams params = new QueryParams();
+ params.asList().add(QueryParams.Entry.forKeyValue("a b", "c d"));
+ params.asList().add(QueryParams.Entry.forLoneKey("e f"));
+
+ // URLEncoder encodes spaces as +
+ assertThat(params.toRawQuery()).isEqualTo("a+b=c+d&e+f");
+ }
+
+ @Test
+ public void parseInvalidPercentEncodingThrows() {
+ assertThrows(IllegalArgumentException.class, () -> QueryParams.fromRawQuery("a=%GH"));
+ }
+
+ @Test
+ public void parseInvalidKeyValueEncodingSucceeds() {
+ QueryParams params = QueryParams.fromRawQuery("====");
+ assertThat(params.asList())
+ .containsExactly(Entry.forRawKeyValue("", "==="))
+ .inOrder();
+ assertThat(params.toRawQuery()).isEqualTo("====");
+ }
+
+ @Test
+ public void uriIntegration_canBuild() {
+ QueryParams params = new QueryParams();
+ params.asList().add(Entry.forKeyValue("a", "b"));
+ params.asList().add(Entry.forKeyValue("c", "d"));
+
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("http")
+ .setHost("example.com")
+ .setRawQuery(params.toRawQuery())
+ .build();
+
+ assertThat(uri.toString()).isEqualTo("http://example.com?a=b&c=d");
+ assertThat(uri.getRawQuery()).isEqualTo("a=b&c=d");
+ }
+
+ @Test
+ public void uriIntegration_canBuildEmpty() {
+ QueryParams params = new QueryParams();
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("http")
+ .setHost("example.com")
+ .setRawQuery(params.toRawQuery())
+ .build();
+
+ assertThat(uri.toString()).isEqualTo("http://example.com");
+ assertThat(uri.getRawQuery()).isNull();
+ }
+
+ @Test
+ public void uriIntegration_canParse() {
+ Uri uri = Uri.create("http://example.com?a=b&c=d&e");
+ QueryParams params = QueryParams.fromRawQuery(uri.getRawQuery());
+
+ assertThat(params.asList())
+ .containsExactly(
+ Entry.forKeyValue("a", "b"), Entry.forKeyValue("c", "d"), Entry.forLoneKey("e"))
+ .inOrder();
+ }
+
+ @Test
+ public void keysAndValuesWithCharactersNeedingUrlEncoding() {
+ QueryParams params = new QueryParams();
+ params.asList().add(Entry.forKeyValue("a=b", "c&d"));
+ params.asList().add(Entry.forKeyValue("e+f", "g h"));
+
+ assertThat(params.toRawQuery()).isEqualTo("a%3Db=c%26d&e%2Bf=g+h");
+
+ QueryParams roundTripped = QueryParams.fromRawQuery(params.toRawQuery());
+ assertThat(roundTripped).isEqualTo(params);
+ }
+
+ @Test
+ public void keysAndValuesWithCodePointsOutsideAsciiRange() {
+ QueryParams params = new QueryParams();
+ params.asList().add(Entry.forKeyValue("€", "𐐷"));
+
+ assertThat(params.toRawQuery()).isEqualTo("%E2%82%AC=%F0%90%90%B7");
+
+ QueryParams roundTripped = QueryParams.fromRawQuery(params.toRawQuery());
+ assertThat(roundTripped).isEqualTo(params);
+ }
+
+ @Test
+ public void toStringMethod() {
+ QueryParams params = new QueryParams();
+ assertThat(params.toString()).isEqualTo("[]");
+
+ params.asList().add(Entry.forKeyValue("a", "b"));
+ assertThat(params.toString()).isEqualTo("[a=b]");
+
+ params.asList().add(Entry.forLoneKey("c"));
+ assertThat(params.toString()).isEqualTo("[a=b, c]");
+
+ params.asList().add(Entry.forKeyValue("d=e", "f&g"));
+ assertThat(params.toString()).isEqualTo("[a=b, c, d%3De=f%26g]");
+ }
+
+ @Test
+ public void entryProperties() {
+ Entry keyValue = Entry.forKeyValue("key", "val");
+ assertThat(keyValue.getKey()).isEqualTo("key");
+ assertThat(keyValue.getValue()).isEqualTo("val");
+ assertThat(keyValue.hasValue()).isTrue();
+
+ Entry loneKey = Entry.forLoneKey("key");
+ assertThat(loneKey.getKey()).isEqualTo("key");
+ assertThat(loneKey.getValue()).isNull();
+ assertThat(loneKey.hasValue()).isFalse();
+ }
+
+ @Test
+ public void equalsAndHashCode_container() {
+ QueryParams params1 = new QueryParams();
+ QueryParams params2 = new QueryParams();
+
+ // Empty instances are equal
+ assertThat(params1).isEqualTo(params2);
+ assertThat(params1.hashCode()).isEqualTo(params2.hashCode());
+
+ params1.asList().add(Entry.forKeyValue("a", "b"));
+ params1.asList().add(Entry.forLoneKey("c"));
+
+ params2.asList().add(Entry.forKeyValue("a", "b"));
+ params2.asList().add(Entry.forLoneKey("c"));
+
+ // Identical parameters in identical order are equal
+ assertThat(params1).isEqualTo(params2);
+ assertThat(params1.hashCode()).isEqualTo(params2.hashCode());
+
+ // Order matters.
+ QueryParams params3 = new QueryParams();
+ params3.asList().add(Entry.forLoneKey("c"));
+ params3.asList().add(Entry.forKeyValue("a", "b"));
+ assertThat(params1).isNotEqualTo(params3);
+ }
+
+ @Test
+ public void equalsAndHashCode_entry() {
+ // Raw matches are equal.
+ assertThat(Entry.forRawKeyValue("a+b", "c")).isEqualTo(Entry.forRawKeyValue("a+b", "c"));
+ assertThat(Entry.forRawKeyValue("a+b", "c").hashCode())
+ .isEqualTo(Entry.forRawKeyValue("a+b", "c").hashCode());
+
+ // Spaces encoding matters. + and %20 are not equal.
+ assertThat(Entry.forRawKeyValue("a+b", "c")).isNotEqualTo(Entry.forRawKeyValue("a%20b", "c"));
+
+ // Case of hex digits matter: %4A vs %4a are not equal raw keys.
+ assertThat(Entry.forRawKeyValue("a", "%4A")).isNotEqualTo(Entry.forRawKeyValue("a", "%4a"));
+ }
+}
diff --git a/api/src/test/java/io/grpc/ServiceProvidersTest.java b/api/src/test/java/io/grpc/ServiceProvidersTest.java
index 7d4388a5bb9..f971ed42646 100644
--- a/api/src/test/java/io/grpc/ServiceProvidersTest.java
+++ b/api/src/test/java/io/grpc/ServiceProvidersTest.java
@@ -16,6 +16,7 @@
package io.grpc;
+import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
@@ -23,12 +24,15 @@
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableList;
import io.grpc.InternalServiceProviders.PriorityAccessor;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ServiceConfigurationError;
+import java.util.ServiceLoader;
+import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -36,7 +40,6 @@
/** Unit tests for {@link ServiceProviders}. */
@RunWith(JUnit4.class)
public class ServiceProvidersTest {
- private static final List> NO_HARDCODED = Collections.emptyList();
private static final PriorityAccessor ACCESSOR =
new PriorityAccessor() {
@Override
@@ -51,6 +54,19 @@ public int getPriority(ServiceProvidersTestAbstractProvider provider) {
};
private final String serviceFile =
"META-INF/services/io.grpc.ServiceProvidersTestAbstractProvider";
+ private boolean failingHardCodedAccessed;
+ private final Supplier>> failingHardCoded = new Supplier>>() {
+ @Override
+ public Iterable> get() {
+ failingHardCodedAccessed = true;
+ throw new AssertionError();
+ }
+ };
+
+ @After
+ public void tearDown() {
+ assertThat(failingHardCodedAccessed).isFalse();
+ }
@Test
public void contextClassLoaderProvider() {
@@ -69,8 +85,8 @@ public void contextClassLoaderProvider() {
Thread.currentThread().setContextClassLoader(rcll);
assertEquals(
Available7Provider.class,
- ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+ load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR)
+ .getClass());
} finally {
Thread.currentThread().setContextClassLoader(ccl);
}
@@ -85,8 +101,7 @@ public void noProvider() {
serviceFile,
"io/grpc/ServiceProvidersTestAbstractProvider-doesNotExist.txt");
Thread.currentThread().setContextClassLoader(cl);
- assertNull(ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR));
+ assertNull(load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR));
} finally {
Thread.currentThread().setContextClassLoader(ccl);
}
@@ -98,11 +113,11 @@ public void multipleProvider() throws Exception {
"io/grpc/ServiceProvidersTestAbstractProvider-multipleProvider.txt");
assertSame(
Available7Provider.class,
- ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+ load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR)
+ .getClass());
- List providers = ServiceProviders.loadAll(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+ List providers = loadAll(
+ ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
assertEquals(3, providers.size());
assertEquals(Available7Provider.class, providers.get(0).getClass());
assertEquals(Available5Provider.class, providers.get(1).getClass());
@@ -116,8 +131,8 @@ public void unavailableProvider() {
"io/grpc/ServiceProvidersTestAbstractProvider-unavailableProvider.txt");
assertEquals(
Available7Provider.class,
- ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+ load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR)
+ .getClass());
}
@Test
@@ -125,8 +140,7 @@ public void unknownClassProvider() {
ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
"io/grpc/ServiceProvidersTestAbstractProvider-unknownClassProvider.txt");
try {
- ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+ loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
fail("Exception expected");
} catch (ServiceConfigurationError e) {
// noop
@@ -140,8 +154,7 @@ public void exceptionSurfacedToCaller_failAtInit() {
try {
// Even though there is a working provider, if any providers fail then we should fail
// completely to avoid returning something unexpected.
- ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+ loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
fail("Expected exception");
} catch (ServiceConfigurationError expected) {
// noop
@@ -154,8 +167,7 @@ public void exceptionSurfacedToCaller_failAtPriority() {
"io/grpc/ServiceProvidersTestAbstractProvider-failAtPriorityProvider.txt");
try {
// The exception should be surfaced to the caller
- ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+ loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
fail("Expected exception");
} catch (FailAtPriorityProvider.PriorityException expected) {
// noop
@@ -168,8 +180,7 @@ public void exceptionSurfacedToCaller_failAtAvailable() {
"io/grpc/ServiceProvidersTestAbstractProvider-failAtAvailableProvider.txt");
try {
// The exception should be surfaced to the caller
- ServiceProviders.load(
- ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+ loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
fail("Expected exception");
} catch (FailAtAvailableProvider.AvailableException expected) {
// noop
@@ -244,6 +255,30 @@ class RandomClass {}
assertFalse(candidates.iterator().hasNext());
}
+ private static T load(
+ Class klass,
+ Supplier>> hardCoded,
+ ClassLoader cl,
+ PriorityAccessor priorityAccessor) {
+ List candidates = loadAll(klass, hardCoded, cl, priorityAccessor);
+ if (candidates.isEmpty()) {
+ return null;
+ }
+ return candidates.get(0);
+ }
+
+ private static List loadAll(
+ Class klass,
+ Supplier>> hardCoded,
+ ClassLoader classLoader,
+ PriorityAccessor priorityAccessor) {
+ return ServiceProviders.loadAll(
+ klass,
+ ServiceLoader.load(klass, classLoader).iterator(),
+ hardCoded,
+ priorityAccessor);
+ }
+
private static class BaseProvider extends ServiceProvidersTestAbstractProvider {
private final boolean isAvailable;
private final int priority;
diff --git a/api/src/test/java/io/grpc/UriTest.java b/api/src/test/java/io/grpc/UriTest.java
new file mode 100644
index 00000000000..0de7ef0fc10
--- /dev/null
+++ b/api/src/test/java/io/grpc/UriTest.java
@@ -0,0 +1,828 @@
+/*
+ * Copyright 2025 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assume.assumeNoException;
+
+import com.google.common.net.InetAddresses;
+import com.google.common.testing.EqualsTester;
+import java.net.Inet6Address;
+import java.net.URISyntaxException;
+import java.net.UnknownHostException;
+import java.util.BitSet;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class UriTest {
+
+ @Test
+ public void parse_allComponents() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme://user@host:0443/path?query#fragment");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isEqualTo("user@host:0443");
+ assertThat(uri.getUserInfo()).isEqualTo("user");
+ assertThat(uri.getPort()).isEqualTo(443);
+ assertThat(uri.getRawPort()).isEqualTo("0443");
+ assertThat(uri.getPath()).isEqualTo("/path");
+ assertThat(uri.getRawQuery()).isEqualTo("query");
+ assertThat(uri.getFragment()).isEqualTo("fragment");
+ assertThat(uri.toString()).isEqualTo("scheme://user@host:0443/path?query#fragment");
+ assertThat(uri.isAbsolute()).isFalse(); // Has a fragment.
+ assertThat(uri.isPathAbsolute()).isTrue();
+ assertThat(uri.isPathRootless()).isFalse();
+ }
+
+ @Test
+ public void parse_noAuthority() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme:/path?query#fragment");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isNull();
+ assertThat(uri.getPath()).isEqualTo("/path");
+ assertThat(uri.getRawQuery()).isEqualTo("query");
+ assertThat(uri.getFragment()).isEqualTo("fragment");
+ assertThat(uri.toString()).isEqualTo("scheme:/path?query#fragment");
+ assertThat(uri.isAbsolute()).isFalse(); // Has a fragment.
+ }
+
+ @Test
+ public void parse_ipv6Literal_withPort() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme://[2001:db8::7]:012345");
+ assertThat(uri.getAuthority()).isEqualTo("[2001:db8::7]:012345");
+ assertThat(uri.getRawHost()).isEqualTo("[2001:db8::7]");
+ assertThat(uri.getHost()).isEqualTo("[2001:db8::7]");
+ assertThat(uri.getRawPort()).isEqualTo("012345");
+ assertThat(uri.getPort()).isEqualTo(12345);
+ }
+
+ @Test
+ public void parse_ipv6Literal_noPort() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme://[2001:db8::7]");
+ assertThat(uri.getAuthority()).isEqualTo("[2001:db8::7]");
+ assertThat(uri.getRawHost()).isEqualTo("[2001:db8::7]");
+ assertThat(uri.getHost()).isEqualTo("[2001:db8::7]");
+ assertThat(uri.getRawPort()).isNull();
+ assertThat(uri.getPort()).isLessThan(0);
+ }
+
+ @Test
+ public void parse_ipv6ScopedLiteral() throws URISyntaxException {
+ Uri uri = Uri.parse("http://[fe80::1%25eth0]");
+ assertThat(uri.getRawHost()).isEqualTo("[fe80::1%25eth0]");
+ assertThat(uri.getHost()).isEqualTo("[fe80::1%eth0]");
+ }
+
+ @Test
+ public void parse_ipv6ScopedPercentEncodedLiteral() throws URISyntaxException {
+ Uri uri = Uri.parse("http://[fe80::1%25foo-bar%2Fblah]");
+ assertThat(uri.getRawHost()).isEqualTo("[fe80::1%25foo-bar%2Fblah]");
+ assertThat(uri.getHost()).isEqualTo("[fe80::1%foo-bar/blah]");
+ }
+
+ @Test
+ public void parse_noQuery() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme://authority/path#fragment");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isEqualTo("authority");
+ assertThat(uri.getPath()).isEqualTo("/path");
+ assertThat(uri.getRawQuery()).isNull();
+ assertThat(uri.getFragment()).isEqualTo("fragment");
+ assertThat(uri.toString()).isEqualTo("scheme://authority/path#fragment");
+ }
+
+ @Test
+ public void parse_noFragment() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme://authority/path?query");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isEqualTo("authority");
+ assertThat(uri.getPath()).isEqualTo("/path");
+ assertThat(uri.getRawQuery()).isEqualTo("query");
+ assertThat(uri.getFragment()).isNull();
+ assertThat(uri.toString()).isEqualTo("scheme://authority/path?query");
+ assertThat(uri.isAbsolute()).isTrue();
+ }
+
+ @Test
+ public void parse_emptyPathWithAuthority() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme://authority");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isEqualTo("authority");
+ assertThat(uri.getPath()).isEmpty();
+ assertThat(uri.getRawQuery()).isNull();
+ assertThat(uri.getFragment()).isNull();
+ assertThat(uri.toString()).isEqualTo("scheme://authority");
+ assertThat(uri.isAbsolute()).isTrue();
+ assertThat(uri.isPathAbsolute()).isFalse();
+ assertThat(uri.isPathRootless()).isFalse();
+ }
+
+ @Test
+ public void parse_rootless() throws URISyntaxException {
+ Uri uri = Uri.parse("mailto:ceo@company.com?subject=raise");
+ assertThat(uri.getScheme()).isEqualTo("mailto");
+ assertThat(uri.getAuthority()).isNull();
+ assertThat(uri.getPath()).isEqualTo("ceo@company.com");
+ assertThat(uri.getRawQuery()).isEqualTo("subject=raise");
+ assertThat(uri.getFragment()).isNull();
+ assertThat(uri.toString()).isEqualTo("mailto:ceo@company.com?subject=raise");
+ assertThat(uri.isAbsolute()).isTrue();
+ assertThat(uri.isPathAbsolute()).isFalse();
+ assertThat(uri.isPathRootless()).isTrue();
+ }
+
+ @Test
+ public void parse_emptyPath() throws URISyntaxException {
+ Uri uri = Uri.parse("scheme:");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isNull();
+ assertThat(uri.getPath()).isEmpty();
+ assertThat(uri.getRawQuery()).isNull();
+ assertThat(uri.getFragment()).isNull();
+ assertThat(uri.toString()).isEqualTo("scheme:");
+ assertThat(uri.isAbsolute()).isTrue();
+ assertThat(uri.isPathAbsolute()).isFalse();
+ assertThat(uri.isPathRootless()).isFalse();
+ }
+
+ @Test
+ public void parse_emptyQuery() {
+ Uri uri = Uri.create("scheme:?");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getRawQuery()).isEmpty();
+ }
+
+ @Test
+ public void parse_emptyFragment() {
+ Uri uri = Uri.create("scheme:#");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getFragment()).isEmpty();
+ }
+
+ @Test
+ public void parse_emptyUserInfo() {
+ Uri uri = Uri.create("scheme://@host");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isEqualTo("@host");
+ assertThat(uri.getHost()).isEqualTo("host");
+ assertThat(uri.getUserInfo()).isEmpty();
+ assertThat(uri.toString()).isEqualTo("scheme://@host");
+ }
+
+ @Test
+ public void parse_emptyPort() {
+ Uri uri = Uri.create("scheme://host:");
+ assertThat(uri.getScheme()).isEqualTo("scheme");
+ assertThat(uri.getAuthority()).isEqualTo("host:");
+ assertThat(uri.getRawAuthority()).isEqualTo("host:");
+ assertThat(uri.getHost()).isEqualTo("host");
+ assertThat(uri.getPort()).isEqualTo(-1);
+ assertThat(uri.getRawPort()).isEqualTo("");
+ assertThat(uri.toString()).isEqualTo("scheme://host:");
+ }
+
+ @Test
+ public void parse_invalidScheme_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("1scheme://authority/path"));
+ assertThat(e).hasMessageThat().contains("Scheme must start with an alphabetic char");
+
+ e = assertThrows(URISyntaxException.class, () -> Uri.parse(":path"));
+ assertThat(e).hasMessageThat().contains("Scheme must start with an alphabetic char");
+ }
+
+ @Test
+ public void parse_unTerminatedScheme_throws() {
+ URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme/"));
+ assertThat(e).hasMessageThat().contains("Missing required scheme");
+
+ e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme?"));
+ assertThat(e).hasMessageThat().contains("Missing required scheme");
+
+ e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme#"));
+ assertThat(e).hasMessageThat().contains("Missing required scheme");
+ }
+
+ @Test
+ public void parse_invalidCharactersInScheme_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("schem e://authority/path"));
+ assertThat(e).hasMessageThat().contains("Invalid character in scheme");
+ }
+
+ @Test
+ public void parse_unTerminatedAuthority_throws() {
+ Uri uri = Uri.create("s://auth/");
+ assertThat(uri.getAuthority()).isEqualTo("auth");
+ uri = Uri.create("s://auth?");
+ assertThat(uri.getAuthority()).isEqualTo("auth");
+ uri = Uri.create("s://auth#");
+ assertThat(uri.getAuthority()).isEqualTo("auth");
+ }
+
+ @Test
+ public void parse_invalidCharactersInUserinfo_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://u ser@host/path"));
+ assertThat(e).hasMessageThat().contains("Invalid character in userInfo");
+ }
+
+ @Test
+ public void parse_invalidBackslashInUserinfo_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("http://other.com\\@intended.com"));
+ assertThat(e).hasMessageThat().contains("Invalid character in userInfo");
+ }
+
+ @Test
+ public void parse_invalidCharactersInHost_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://h ost/path"));
+ assertThat(e).hasMessageThat().contains("Invalid character in host");
+ }
+
+ @Test
+ public void parse_invalidBackslashInHost_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("http://other.com\\.intended.com"));
+ assertThat(e).hasMessageThat().contains("Invalid character in host");
+ }
+
+ @Test
+ public void parse_invalidBackslashScope_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("http://[::1%25foo\\bar]"));
+ assertThat(e).hasMessageThat().contains("Invalid character in scope");
+ }
+
+ @Test
+ public void parse_invalidCharactersInPort_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://user@host:8 0/path"));
+ assertThat(e).hasMessageThat().contains("Invalid character");
+ }
+
+ @Test
+ public void parse_nonAsciiCharacterInPath_throws() throws URISyntaxException {
+ URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("foo:bär"));
+ assertThat(e).hasMessageThat().contains("Invalid character in path");
+ }
+
+ @Test
+ public void parse_invalidCharactersInPath_throws() {
+ URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme:/p ath"));
+ assertThat(e).hasMessageThat().contains("Invalid character in path");
+ }
+
+ @Test
+ public void parse_invalidCharactersInQuery_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://user@host/p?q[]uery"));
+ assertThat(e).hasMessageThat().contains("Invalid character in query");
+ }
+
+ @Test
+ public void parse_invalidCharactersInFragment_throws() {
+ URISyntaxException e =
+ assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://user@host/path#f[]rag"));
+ assertThat(e).hasMessageThat().contains("Invalid character in fragment");
+ }
+
+ @Test
+ public void parse_nonAsciiCharacterInFragment_throws() throws URISyntaxException {
+ URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("foo:#bär"));
+ assertThat(e).hasMessageThat().contains("Invalid character in fragment");
+ }
+
+ @Test
+ public void parse_decoding() throws URISyntaxException {
+ Uri uri = Uri.parse("s://user%2Ename:pass%2Eword@a%2db:1234/p%20ath?q%20uery#f%20ragment");
+ assertThat(uri.getAuthority()).isEqualTo("user.name:pass.word@a-b:1234");
+ assertThat(uri.getRawAuthority()).isEqualTo("user%2Ename:pass%2Eword@a%2db:1234");
+ assertThat(uri.getUserInfo()).isEqualTo("user.name:pass.word");
+ assertThat(uri.getRawUserInfo()).isEqualTo("user%2Ename:pass%2Eword");
+ assertThat(uri.getHost()).isEqualTo("a-b");
+ assertThat(uri.getRawHost()).isEqualTo("a%2db");
+ assertThat(uri.getPort()).isEqualTo(1234);
+ assertThat(uri.getPath()).isEqualTo("/p ath");
+ assertThat(uri.getRawPath()).isEqualTo("/p%20ath");
+ assertThat(uri.getRawQuery()).isEqualTo("q%20uery");
+ assertThat(uri.getFragment()).isEqualTo("f ragment");
+ assertThat(uri.getRawFragment()).isEqualTo("f%20ragment");
+ }
+
+ @Test
+ public void parse_decodingNonAscii() throws URISyntaxException {
+ Uri uri = Uri.parse("s://a/%E2%82%AC");
+ assertThat(uri.getPath()).isEqualTo("/€");
+ }
+
+ @Test
+ public void parse_decodingPercent() throws URISyntaxException {
+ Uri uri = Uri.parse("s://a/p%2520ath#f%25ragment");
+ assertThat(uri.getPath()).isEqualTo("/p%20ath");
+ assertThat(uri.getFragment()).isEqualTo("f%ragment");
+ }
+
+ @Test
+ public void parse_invalidPercentEncoding_throws() {
+ URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("s://a/p%2"));
+ assertThat(e).hasMessageThat().contains("Invalid");
+
+ e = assertThrows(URISyntaxException.class, () -> Uri.parse("s://a/p%2G"));
+ assertThat(e).hasMessageThat().contains("Invalid");
+ }
+
+ @Test
+ public void parse_emptyAuthority() {
+ Uri uri = Uri.create("file:///foo/bar");
+ assertThat(uri.getAuthority()).isEmpty();
+ assertThat(uri.getHost()).isEmpty();
+ assertThat(uri.getUserInfo()).isNull();
+ assertThat(uri.getPort()).isEqualTo(-1);
+ assertThat(uri.getPath()).isEqualTo("/foo/bar");
+ }
+
+ @Test
+ public void parse_pathSegments_empty() throws URISyntaxException {
+ Uri uri = Uri.create("scheme:");
+ assertThat(uri.getPathSegments()).isEmpty();
+ }
+
+ @Test
+ public void parse_pathSegments_root() throws URISyntaxException {
+ Uri uri = Uri.create("scheme:/");
+ assertThat(uri.getPathSegments()).containsExactly("");
+ }
+
+ @Test
+ public void parse_onePathSegment() throws URISyntaxException {
+ Uri uri = Uri.create("file:/foo");
+ assertThat(uri.getPathSegments()).containsExactly("foo");
+ }
+
+ @Test
+ public void parse_onePathSegment_trailingSlash() throws URISyntaxException {
+ Uri uri = Uri.create("file:/foo/");
+ assertThat(uri.getPathSegments()).containsExactly("foo", "");
+ }
+
+ @Test
+ public void parse_onePathSegment_rootless() throws URISyntaxException {
+ Uri uri = Uri.create("dns:www.example.com");
+ assertThat(uri.getPathSegments()).containsExactly("www.example.com");
+ assertThat(uri.isPathAbsolute()).isFalse();
+ assertThat(uri.isPathRootless()).isTrue();
+ }
+
+ @Test
+ public void parse_twoPathSegments() throws URISyntaxException {
+ Uri uri = Uri.create("file:/foo/bar");
+ assertThat(uri.getPathSegments()).containsExactly("foo", "bar");
+ }
+
+ @Test
+ public void parse_twoPathSegments_rootless() throws URISyntaxException {
+ Uri uri = Uri.create("file:foo/bar");
+ assertThat(uri.getPathSegments()).containsExactly("foo", "bar");
+ }
+
+ @Test
+ public void parse_percentEncodedPathSegment_rootless() throws URISyntaxException {
+ Uri uri = Uri.create("mailto:%2Fdev%2Fnull@example.com");
+ assertThat(uri.getPathSegments()).containsExactly("/dev/null@example.com");
+ assertThat(uri.isPathAbsolute()).isFalse();
+ assertThat(uri.isPathRootless()).isTrue();
+ }
+
+ @Test
+ public void toString_percentEncoding() throws URISyntaxException {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("s")
+ .setHost("a b")
+ .setPath("/p ath")
+ .setRawQuery("q%20uery")
+ .setFragment("f ragment")
+ .build();
+ assertThat(uri.toString()).isEqualTo("s://a%20b/p%20ath?q%20uery#f%20ragment");
+ }
+
+ @Test
+ public void parse_transparentRoundTrip_ipLiteral() {
+ Uri uri = Uri.create("http://[2001:dB8::7]:080/%4a%4B%2f%2F?%4c%4D#%4e%4F").toBuilder().build();
+ assertThat(uri.toString()).isEqualTo("http://[2001:dB8::7]:080/%4a%4B%2f%2F?%4c%4D#%4e%4F");
+
+ // IPv6 host has non-canonical :: zeros and mixed case hex digits.
+ assertThat(uri.getRawHost()).isEqualTo("[2001:dB8::7]");
+ assertThat(uri.getHost()).isEqualTo("[2001:dB8::7]");
+ assertThat(uri.getRawPort()).isEqualTo("080"); // Leading zeros.
+ assertThat(uri.getPort()).isEqualTo(80);
+ // Unnecessary and mixed case percent encodings.
+ assertThat(uri.getRawPath()).isEqualTo("/%4a%4B%2f%2F");
+ assertThat(uri.getPathSegments()).containsExactly("JK//");
+ assertThat(uri.getRawQuery()).isEqualTo("%4c%4D");
+ assertThat(uri.getRawFragment()).isEqualTo("%4e%4F");
+ assertThat(uri.getFragment()).isEqualTo("NO");
+ }
+
+ @Test
+ public void parse_transparentRoundTrip_regName() {
+ Uri uri = Uri.create("http://aB%4A%4b:080/%4a%4B%2f%2F?%4c%4D#%4e%4F").toBuilder().build();
+ assertThat(uri.toString()).isEqualTo("http://aB%4A%4b:080/%4a%4B%2f%2F?%4c%4D#%4e%4F");
+
+ // Mixed case literal chars and hex digits.
+ assertThat(uri.getRawHost()).isEqualTo("aB%4A%4b");
+ assertThat(uri.getHost()).isEqualTo("aBJK");
+ assertThat(uri.getRawPort()).isEqualTo("080"); // Leading zeros.
+ assertThat(uri.getPort()).isEqualTo(80);
+ // Unnecessary and mixed case percent encodings.
+ assertThat(uri.getRawPath()).isEqualTo("/%4a%4B%2f%2F");
+ assertThat(uri.getPathSegments()).containsExactly("JK//");
+ assertThat(uri.getRawQuery()).isEqualTo("%4c%4D");
+ assertThat(uri.getRawFragment()).isEqualTo("%4e%4F");
+ assertThat(uri.getFragment()).isEqualTo("NO");
+ }
+
+ @Test
+ public void builder_numericPort() throws URISyntaxException {
+ Uri uri = Uri.newBuilder().setScheme("scheme").setHost("host").setPort(80).build();
+ assertThat(uri.toString()).isEqualTo("scheme://host:80");
+ }
+
+ @Test
+ public void builder_ipv6Literal() throws URISyntaxException {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("scheme")
+ .setHost(InetAddresses.forString("2001:4860:4860::8844"))
+ .build();
+ assertThat(uri.toString()).isEqualTo("scheme://[2001:4860:4860::8844]");
+ }
+
+ @Test
+ public void builder_ipv6ScopedLiteral_numeric() throws UnknownHostException {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("http")
+ // Create an address with a numeric scope_id, which should always be valid.
+ .setHost(
+ Inet6Address.getByAddress(null, InetAddresses.forString("fe80::1").getAddress(), 1))
+ .build();
+
+ // We expect the scope ID to be percent encoded.
+ assertThat(uri.getRawHost()).isEqualTo("[fe80::1%251]");
+ assertThat(uri.getHost()).isEqualTo("[fe80::1%1]");
+ }
+
+ @Test
+ public void builder_ipv6ScopedLiteral_named() throws UnknownHostException {
+ // Unfortunately, there's no Java API to create an Inet6Address with an arbitrary interface-
+ // scoped name. There's actually no way to hermetically create an Inet6Address with a scope name
+ // at all! The following address/interface is likely to be present on Linux test runners.
+ Inet6Address address;
+ try {
+ address = (Inet6Address) InetAddresses.forString("::1%lo");
+ } catch (IllegalArgumentException e) {
+ assumeNoException(e);
+ return; // Not reached.
+ }
+ Uri uri = Uri.newBuilder().setScheme("http").setHost(address).build();
+
+ // We expect the scope ID to be percent encoded.
+ assertThat(uri.getRawHost()).isEqualTo("[::1%25lo]");
+ assertThat(uri.getHost()).isEqualTo("[::1%lo]");
+ }
+
+ @Test
+ public void builder_ipv6PercentEncodedScopedLiteral() {
+ Uri uri = Uri.newBuilder().setScheme("http").setRawHost("[fe80::1%25foo%2Dbar%2Fblah]").build();
+ assertThat(uri.getRawHost()).isEqualTo("[fe80::1%25foo%2Dbar%2Fblah]");
+ assertThat(uri.getHost()).isEqualTo("[fe80::1%foo-bar/blah]");
+ }
+
+ @Test
+ public void builder_encodingWithAllowedReservedChars() throws URISyntaxException {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("s")
+ .setUserInfo("u@")
+ .setHost("a[]")
+ .setPath("/p:/@")
+ .setRawQuery("q/?")
+ .setFragment("f/?")
+ .build();
+ assertThat(uri.toString()).isEqualTo("s://u%40@a%5B%5D/p:/@?q/?#f/?");
+ }
+
+ @Test
+ public void builder_percentEncodingNonAscii() throws URISyntaxException {
+ Uri uri = Uri.newBuilder().setScheme("s").setHost("a").setPath("/€").build();
+ assertThat(uri.toString()).isEqualTo("s://a/%E2%82%AC");
+ }
+
+ @Test
+ public void builder_percentEncodingLoneHighSurrogate_throws() {
+ IllegalArgumentException e =
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> Uri.newBuilder().setPath("\uD83D")); // Lone high surrogate.
+ assertThat(e.getMessage()).contains("Malformed input");
+ }
+
+ @Test
+ public void builder_hasAuthority_pathStartsWithSlash_throws() throws URISyntaxException {
+ IllegalArgumentException e =
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> Uri.newBuilder().setScheme("s").setHost("a").setPath("path").build());
+ assertThat(e.getMessage()).contains("Non-empty path must start with '/'");
+ }
+
+ @Test
+ public void builder_noAuthority_pathStartsWithDoubleSlash_throws() throws URISyntaxException {
+ IllegalArgumentException e =
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> Uri.newBuilder().setScheme("s").setPath("//path").build());
+ assertThat(e.getMessage()).contains("Path cannot start with '//'");
+ }
+
+ @Test
+ public void builder_noScheme_throws() {
+ IllegalStateException e =
+ assertThrows(IllegalStateException.class, () -> Uri.newBuilder().build());
+ assertThat(e.getMessage()).contains("Missing required scheme");
+ }
+
+ @Test
+ public void builder_noHost_hasUserInfo_throws() {
+ IllegalStateException e =
+ assertThrows(
+ IllegalStateException.class,
+ () -> Uri.newBuilder().setScheme("scheme").setUserInfo("user").build());
+ assertThat(e.getMessage()).contains("Cannot set userInfo without host");
+ }
+
+ @Test
+ public void builder_noHost_hasPort_throws() {
+ IllegalStateException e =
+ assertThrows(
+ IllegalStateException.class,
+ () -> Uri.newBuilder().setScheme("scheme").setPort(1234).build());
+ assertThat(e.getMessage()).contains("Cannot set port without host");
+ }
+
+ @Test
+ public void builder_normalizesCaseWhereAppropriate() {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("hTtP") // #section-3.1 says producers (Builder) should normalize to lower.
+ .setHost("aBc") // #section-3.2.2 says producers (Builder) should normalize to lower.
+ .setPath("/CdE") // #section-6.2.2.1 says the rest are assumed to be case-sensitive
+ .setRawQuery("fGh")
+ .setFragment("IjK")
+ .build();
+ assertThat(uri.toString()).isEqualTo("http://abc/CdE?fGh#IjK");
+ }
+
+ @Test
+ public void builder_normalizesIpv6Literal() {
+ Uri uri =
+ Uri.newBuilder().setScheme("scheme").setHost(InetAddresses.forString("ABCD::EFAB")).build();
+ assertThat(uri.toString()).isEqualTo("scheme://[abcd::efab]");
+ }
+
+ @Test
+ public void builder_canClearAllOptionalFields() {
+ Uri uri =
+ Uri.create("http://user@host:80/path?query#fragment").toBuilder()
+ .setHost((String) null)
+ .setPath("")
+ .setUserInfo(null)
+ .setPort(-1)
+ .setRawQuery(null)
+ .setFragment(null)
+ .build();
+ assertThat(uri.toString()).isEqualTo("http:");
+ }
+
+ @Test
+ public void builder_setRawQuery() {
+ Uri uri = Uri.newBuilder().setScheme("http").setHost("host").setRawQuery("%61=b&c=%64").build();
+ assertThat(uri.getRawQuery()).isEqualTo("%61=b&c=%64");
+ assertThat(uri.toString()).isEqualTo("http://host?%61=b&c=%64");
+ }
+
+ @Test
+ public void builder_setRawQuery_null() {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("http")
+ .setHost("host")
+ .setRawQuery("a=b")
+ .setRawQuery(null)
+ .build();
+ assertThat(uri.getRawQuery()).isNull();
+ assertThat(uri.toString()).isEqualTo("http://host");
+ }
+
+ @Test
+ public void builder_setRawFragment() {
+ Uri uri = Uri.newBuilder().setScheme("http").setHost("host").setRawFragment("a%20b").build();
+ assertThat(uri.getRawFragment()).isEqualTo("a%20b");
+ assertThat(uri.getFragment()).isEqualTo("a b");
+ assertThat(uri.toString()).isEqualTo("http://host#a%20b");
+ }
+
+ @Test
+ public void builder_setRawFragment_null() {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("http")
+ .setHost("host")
+ .setRawFragment("a%20b")
+ .setRawFragment(null)
+ .build();
+ assertThat(uri.getRawFragment()).isNull();
+ assertThat(uri.getFragment()).isNull();
+ assertThat(uri.toString()).isEqualTo("http://host");
+ }
+
+ @Test
+ public void builder_setRawFragment_invalidCharacters_throws() {
+ IllegalArgumentException e =
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> Uri.newBuilder().setRawFragment("f[]rag"));
+ assertThat(e).hasMessageThat().contains("Invalid character in fragment");
+ }
+
+ @Test
+ public void builder_setRawFragment_invalidPercentEncoding_throws() {
+ IllegalArgumentException e =
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> Uri.newBuilder().setRawFragment("f%XXragment"));
+ assertThat(e).hasMessageThat().contains("Invalid");
+ }
+
+ @Test
+ public void builder_canClearAuthorityComponents() {
+ Uri uri = Uri.create("s://user@host:80/path").toBuilder().setRawAuthority(null).build();
+ assertThat(uri.toString()).isEqualTo("s:/path");
+ }
+
+ @Test
+ public void builder_canSetEmptyAuthority() {
+ Uri uri = Uri.create("s://user@host:80/path").toBuilder().setRawAuthority("").build();
+ assertThat(uri.toString()).isEqualTo("s:///path");
+ }
+
+ @Test
+ public void builder_canSetRawAuthority() {
+ Uri uri = Uri.newBuilder().setScheme("http").setRawAuthority("user@host:1234").build();
+ assertThat(uri.getUserInfo()).isEqualTo("user");
+ assertThat(uri.getHost()).isEqualTo("host");
+ assertThat(uri.getPort()).isEqualTo(1234);
+ }
+
+ @Test
+ public void builder_setRawAuthorityPercentDecodes() {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("http")
+ .setRawAuthority("user:user%40user@host%40host%3Ahost")
+ .build();
+ assertThat(uri.getUserInfo()).isEqualTo("user:user@user");
+ assertThat(uri.getHost()).isEqualTo("host@host:host");
+ assertThat(uri.getPort()).isEqualTo(-1);
+ }
+
+ @Test
+ public void builder_setRawAuthorityReplacesAllComponents() {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("http")
+ .setUserInfo("user")
+ .setHost("host")
+ .setPort(1234)
+ .setRawAuthority("other")
+ .build();
+ assertThat(uri.getUserInfo()).isNull();
+ assertThat(uri.getHost()).isEqualTo("other");
+ assertThat(uri.getPort()).isEqualTo(-1);
+ }
+
+ @Test
+ public void toString_percentEncodingMultiChar() throws URISyntaxException {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("s")
+ .setHost("a")
+ .setPath("/emojis/😊/icon.png") // Smile requires two chars to express in a java String.
+ .build();
+ assertThat(uri.toString()).isEqualTo("s://a/emojis/%F0%9F%98%8A/icon.png");
+ }
+
+ @Test
+ public void toString_percentEncodingLiteralPercent() throws URISyntaxException {
+ Uri uri =
+ Uri.newBuilder()
+ .setScheme("s")
+ .setHost("a")
+ .setPath("/p%20ath")
+ .setRawQuery("q%25uery")
+ .setFragment("f%ragment")
+ .build();
+ assertThat(uri.toString()).isEqualTo("s://a/p%2520ath?q%25uery#f%25ragment");
+ }
+
+ @Test
+ public void equalsAndHashCode() {
+ new EqualsTester()
+ .addEqualityGroup(
+ Uri.create("scheme://authority/path?query#fragment"),
+ Uri.create("scheme://authority/path?query#fragment"))
+ .addEqualityGroup(Uri.create("scheme://authority/path"))
+ .addEqualityGroup(Uri.create("scheme://authority/path?query"))
+ .addEqualityGroup(Uri.create("scheme:/path"))
+ .addEqualityGroup(Uri.create("scheme:/path?query"))
+ .addEqualityGroup(Uri.create("scheme:/path#fragment"))
+ .addEqualityGroup(Uri.create("scheme:path"))
+ .addEqualityGroup(Uri.create("scheme:path?query"))
+ .addEqualityGroup(Uri.create("scheme:path#fragment"))
+ .addEqualityGroup(Uri.create("scheme:"))
+ .testEquals();
+ }
+
+ @Test
+ public void isAbsolute() {
+ assertThat(Uri.create("scheme://authority/path").isAbsolute()).isTrue();
+ assertThat(Uri.create("scheme://authority/path?query").isAbsolute()).isTrue();
+ assertThat(Uri.create("scheme://authority/path#fragment").isAbsolute()).isFalse();
+ assertThat(Uri.create("scheme://authority/path?query#fragment").isAbsolute()).isFalse();
+ }
+
+ @Test
+ public void serializedCharacterClasses_matchComputed() {
+ assertThat(Uri.digitChars).isEqualTo(bitSetOfRange('0', '9'));
+ assertThat(Uri.alphaChars).isEqualTo(or(bitSetOfRange('A', 'Z'), bitSetOfRange('a', 'z')));
+ assertThat(Uri.schemeChars)
+ .isEqualTo(or(Uri.digitChars, Uri.alphaChars, bitSetOf('+', '-', '.')));
+ assertThat(Uri.unreservedChars)
+ .isEqualTo(or(Uri.alphaChars, Uri.digitChars, bitSetOf('-', '.', '_', '~')));
+ assertThat(Uri.genDelimsChars).isEqualTo(bitSetOf(':', '/', '?', '#', '[', ']', '@'));
+ assertThat(Uri.subDelimsChars)
+ .isEqualTo(bitSetOf('!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '='));
+ assertThat(Uri.reservedChars).isEqualTo(or(Uri.genDelimsChars, Uri.subDelimsChars));
+ assertThat(Uri.regNameChars).isEqualTo(or(Uri.unreservedChars, Uri.subDelimsChars));
+ assertThat(Uri.userInfoChars)
+ .isEqualTo(or(Uri.unreservedChars, Uri.subDelimsChars, bitSetOf(':')));
+ assertThat(Uri.pChars)
+ .isEqualTo(or(Uri.unreservedChars, Uri.subDelimsChars, bitSetOf(':', '@')));
+ assertThat(Uri.pCharsAndSlash).isEqualTo(or(Uri.pChars, bitSetOf('/')));
+ assertThat(Uri.queryChars).isEqualTo(or(Uri.pChars, bitSetOf('/', '?')));
+ assertThat(Uri.fragmentChars).isEqualTo(or(Uri.pChars, bitSetOf('/', '?')));
+ }
+
+ private static BitSet bitSetOfRange(char from, char to) {
+ BitSet bitset = new BitSet();
+ for (char c = from; c <= to; c++) {
+ bitset.set(c);
+ }
+ return bitset;
+ }
+
+ private static BitSet bitSetOf(char... chars) {
+ BitSet bitset = new BitSet();
+ for (char c : chars) {
+ bitset.set(c);
+ }
+ return bitset;
+ }
+
+ private static BitSet or(BitSet... bitsets) {
+ BitSet bitset = new BitSet();
+ for (BitSet bs : bitsets) {
+ bitset.or(bs);
+ }
+ return bitset;
+ }
+}
diff --git a/api/src/testFixtures/java/io/grpc/FlagResetRule.java b/api/src/testFixtures/java/io/grpc/FlagResetRule.java
new file mode 100644
index 00000000000..08ce7ce82f2
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/FlagResetRule.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import javax.annotation.Nullable;
+import org.junit.rules.ExternalResource;
+
+/**
+ * A {@link org.junit.rules.TestRule} that lets you set one or more feature flags just for
+ * the duration of the current test case.
+ *
+ * Flags and other global variables must be reset to ensure no state leaks across tests.
+ */
+public final class FlagResetRule extends ExternalResource {
+
+ /** A functional interface representing a standard gRPC feature flag setter. */
+ public interface SetterMethod {
+ /** Sets a flag for testing and returns its previous value. */
+ T set(T val);
+ }
+
+ private final Deque toRunAfter = new ArrayDeque<>();
+
+ /**
+ * Sets a global feature flag to 'value' using 'setter' and arranges for its previous value to be
+ * unconditionally restored when the test completes.
+ */
+ public void setFlagForTest(SetterMethod setter, T value) {
+ final T oldValue = setter.set(value);
+ toRunAfter.push(() -> setter.set(oldValue));
+ }
+
+ /**
+ * Sets java system property 'key' to 'value' and arranges for its previous value to be
+ * unconditionally restored when the test completes.
+ */
+ public void setSystemPropertyForTest(String key, String value) {
+ String oldValue = System.setProperty(key, value);
+ restoreSystemPropertyAfterTest(key, oldValue);
+ }
+
+ /**
+ * Clears java system property 'key' and arranges for its previous value to be unconditionally
+ * restored when the test completes.
+ */
+ public void clearSystemPropertyForTest(String key) {
+ String oldValue = System.clearProperty(key);
+ restoreSystemPropertyAfterTest(key, oldValue);
+ }
+
+ private void restoreSystemPropertyAfterTest(String key, @Nullable String oldValue) {
+ toRunAfter.push(
+ () -> {
+ if (oldValue == null) {
+ System.clearProperty(key);
+ } else {
+ System.setProperty(key, oldValue);
+ }
+ });
+ }
+
+ @Override
+ protected void after() {
+ RuntimeException toThrow = null;
+ while (!toRunAfter.isEmpty()) {
+ try {
+ toRunAfter.pop().run();
+ } catch (RuntimeException e) {
+ if (toThrow == null) {
+ toThrow = e;
+ } else {
+ toThrow.addSuppressed(e);
+ }
+ }
+ }
+ if (toThrow != null) {
+ throw toThrow;
+ }
+ }
+}
diff --git a/api/src/testFixtures/java/io/grpc/StatusMatcher.java b/api/src/testFixtures/java/io/grpc/StatusMatcher.java
index f464b2d709d..08e9fffb013 100644
--- a/api/src/testFixtures/java/io/grpc/StatusMatcher.java
+++ b/api/src/testFixtures/java/io/grpc/StatusMatcher.java
@@ -26,7 +26,7 @@
*/
public final class StatusMatcher implements ArgumentMatcher {
public static StatusMatcher statusHasCode(ArgumentMatcher codeMatcher) {
- return new StatusMatcher(codeMatcher, null);
+ return new StatusMatcher(codeMatcher, null, null);
}
public static StatusMatcher statusHasCode(Status.Code code) {
@@ -35,17 +35,20 @@ public static StatusMatcher statusHasCode(Status.Code code) {
private final ArgumentMatcher codeMatcher;
private final ArgumentMatcher descriptionMatcher;
+ private final ArgumentMatcher causeMatcher;
private StatusMatcher(
ArgumentMatcher codeMatcher,
- ArgumentMatcher descriptionMatcher) {
+ ArgumentMatcher descriptionMatcher,
+ ArgumentMatcher causeMatcher) {
this.codeMatcher = checkNotNull(codeMatcher, "codeMatcher");
this.descriptionMatcher = descriptionMatcher;
+ this.causeMatcher = causeMatcher;
}
public StatusMatcher andDescription(ArgumentMatcher descriptionMatcher) {
checkState(this.descriptionMatcher == null, "Already has a description matcher");
- return new StatusMatcher(codeMatcher, descriptionMatcher);
+ return new StatusMatcher(codeMatcher, descriptionMatcher, causeMatcher);
}
public StatusMatcher andDescription(String description) {
@@ -56,11 +59,21 @@ public StatusMatcher andDescriptionContains(String substring) {
return andDescription(new StringContainsMatcher(substring));
}
+ public StatusMatcher andCause(ArgumentMatcher causeMatcher) {
+ checkState(this.causeMatcher == null, "Already has a cause matcher");
+ return new StatusMatcher(codeMatcher, descriptionMatcher, causeMatcher);
+ }
+
+ public StatusMatcher andCause(Throwable cause) {
+ return andCause(new EqualsMatcher<>(cause));
+ }
+
@Override
public boolean matches(Status status) {
return status != null
&& codeMatcher.matches(status.getCode())
- && (descriptionMatcher == null || descriptionMatcher.matches(status.getDescription()));
+ && (descriptionMatcher == null || descriptionMatcher.matches(status.getDescription()))
+ && (causeMatcher == null || causeMatcher.matches(status.getCause()));
}
@Override
@@ -72,6 +85,10 @@ public String toString() {
sb.append(", description=");
sb.append(descriptionMatcher);
}
+ if (causeMatcher != null) {
+ sb.append(", cause=");
+ sb.append(causeMatcher);
+ }
sb.append("}");
return sb.toString();
}
diff --git a/api/src/testFixtures/java/io/grpc/StatusSubject.java b/api/src/testFixtures/java/io/grpc/StatusSubject.java
new file mode 100644
index 00000000000..0b00df96140
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/StatusSubject.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import static com.google.common.truth.Fact.fact;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import javax.annotation.Nullable;
+
+/** Propositions for {@link Status} subjects. */
+public final class StatusSubject extends Subject {
+
+ private static final Subject.Factory statusFactory = new Factory();
+
+ public static Subject.Factory status() {
+ return statusFactory;
+ }
+
+ private final Status actual;
+
+ private StatusSubject(FailureMetadata metadata, @Nullable Status subject) {
+ super(metadata, subject);
+ this.actual = subject;
+ }
+
+ /** Fails if the subject is not OK. */
+ public void isOk() {
+ if (actual == null) {
+ failWithActual("expected to be OK but was", "null");
+ } else if (!actual.isOk()) {
+ failWithoutActual(
+ fact("expected to be OK but was", actual.getCode()),
+ fact("description", actual.getDescription()),
+ fact("cause", actual.getCause()));
+ }
+ }
+
+ /** Fails if the subject does not have the given code. */
+ public void hasCode(Status.Code expectedCode) {
+ if (actual == null) {
+ failWithActual("expected to have code " + expectedCode + " but was", "null");
+ } else {
+ check("getCode()").that(actual.getCode()).isEqualTo(expectedCode);
+ }
+ }
+
+ private static final class Factory implements Subject.Factory {
+ @Override
+ public StatusSubject createSubject(FailureMetadata metadata, @Nullable Status that) {
+ return new StatusSubject(metadata, that);
+ }
+ }
+}
diff --git a/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java b/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java
index ed7e018412c..183ae2c3f55 100644
--- a/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java
+++ b/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java
@@ -156,19 +156,19 @@ private static Map parseRules(
}
/**
- * Translates a gRPC authorization policy in JSON string to Envoy RBAC policies.
- * On success, will return one of the following -
- * 1. One allow RBAC policy or,
- * 2. Two RBAC policies, deny policy followed by allow policy.
- * If the policy cannot be parsed or is invalid, an exception will be thrown.
- */
+ * Translates a gRPC authorization policy in JSON string to Envoy RBAC policies.
+ * On success, will return one of the following -
+ * 1. One allow RBAC policy or,
+ * 2. Two RBAC policies, deny policy followed by allow policy.
+ * If the policy cannot be parsed or is invalid, an exception will be thrown.
+ */
public static List translate(String authorizationPolicy)
throws IllegalArgumentException, IOException {
Object jsonObject = JsonParser.parse(authorizationPolicy);
if (!(jsonObject instanceof Map)) {
throw new IllegalArgumentException(
- "Authorization policy should be a JSON object. Found: "
- + (jsonObject == null ? null : jsonObject.getClass()));
+ "Authorization policy should be a JSON object. Found: "
+ + (jsonObject == null ? null : jsonObject.getClass()));
}
@SuppressWarnings("unchecked")
Map json = (Map)jsonObject;
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
index d0de1571a59..8c0ef187fbb 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
@@ -41,7 +41,6 @@
import io.grpc.okhttp.OkHttpChannelBuilder;
import io.grpc.stub.StreamObserver;
import io.netty.channel.Channel;
-import io.netty.channel.DefaultEventLoopGroup;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.ServerChannel;
import io.netty.channel.local.LocalAddress;
@@ -103,7 +102,8 @@ public void setUp() throws Exception {
case NETTY_LOCAL: {
String name = "bench" + Math.random();
LocalAddress address = new LocalAddress(name);
- EventLoopGroup group = new DefaultEventLoopGroup();
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ EventLoopGroup group = new io.netty.channel.DefaultEventLoopGroup();
serverBuilder = NettyServerBuilder.forAddress(address, serverCreds)
.bossEventLoopGroup(group)
.workerEventLoopGroup(group)
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
index 6d8a9ec8a8e..ffda287764d 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
@@ -41,7 +41,6 @@
import io.netty.channel.local.LocalAddress;
import io.netty.channel.local.LocalChannel;
import io.netty.channel.local.LocalServerChannel;
-import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.util.concurrent.DefaultThreadFactory;
@@ -229,8 +228,14 @@ public void setup(ExecutorType clientExecutor,
// Always use a different worker group from the client.
ThreadFactory serverThreadFactory = new DefaultThreadFactory("STF pool", true /* daemon */);
- serverBuilder.workerEventLoopGroup(new NioEventLoopGroup(0, serverThreadFactory));
- serverBuilder.bossEventLoopGroup(new NioEventLoopGroup(1, serverThreadFactory));
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ io.netty.channel.EventLoopGroup workerGroup =
+ new io.netty.channel.nio.NioEventLoopGroup(0, serverThreadFactory);
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ io.netty.channel.EventLoopGroup bossGroup =
+ new io.netty.channel.nio.NioEventLoopGroup(1, serverThreadFactory);
+ serverBuilder.workerEventLoopGroup(workerGroup);
+ serverBuilder.bossEventLoopGroup(bossGroup);
// Always set connection and stream window size to same value
serverBuilder.flowControlWindow(windowSize.bytes());
@@ -388,8 +393,11 @@ public void onReady() {
ThreadFactory clientThreadFactory = new DefaultThreadFactory("CTF pool", true /* daemon */);
for (int i = 0; i < channelCount; i++) {
// Use a dedicated event-loop for each channel
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ io.netty.channel.EventLoopGroup elg =
+ new io.netty.channel.nio.NioEventLoopGroup(1, clientThreadFactory);
channels[i] = channelBuilder
- .eventLoopGroup(new NioEventLoopGroup(1, clientThreadFactory))
+ .eventLoopGroup(elg)
.build();
}
}
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java b/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
index c4ba99e1639..9d678761133 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
@@ -35,9 +35,7 @@
import io.grpc.okhttp.OkHttpChannelBuilder;
import io.grpc.testing.TlsTesting;
import io.netty.channel.epoll.EpollDomainSocketChannel;
-import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollSocketChannel;
-import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.channel.unix.DomainSocketAddress;
import io.netty.util.concurrent.DefaultThreadFactory;
@@ -128,22 +126,30 @@ private static NettyChannelBuilder configureNetty(
DefaultThreadFactory tf = new DefaultThreadFactory("client-elg-", true /*daemon */);
switch (transport) {
case NETTY_NIO:
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ io.netty.channel.EventLoopGroup elg = new io.netty.channel.nio.NioEventLoopGroup(0, tf);
builder
- .eventLoopGroup(new NioEventLoopGroup(0, tf))
+ .eventLoopGroup(elg)
.channelType(NioSocketChannel.class, InetSocketAddress.class);
break;
case NETTY_EPOLL:
// These classes only work on Linux.
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ io.netty.channel.EventLoopGroup epollElg =
+ new io.netty.channel.epoll.EpollEventLoopGroup(0, tf);
builder
- .eventLoopGroup(new EpollEventLoopGroup(0, tf))
+ .eventLoopGroup(epollElg)
.channelType(EpollSocketChannel.class, InetSocketAddress.class);
break;
case NETTY_UNIX_DOMAIN_SOCKET:
// These classes only work on Linux.
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ io.netty.channel.EventLoopGroup unixElg =
+ new io.netty.channel.epoll.EpollEventLoopGroup(0, tf);
builder
- .eventLoopGroup(new EpollEventLoopGroup(0, tf))
+ .eventLoopGroup(unixElg)
.channelType(EpollDomainSocketChannel.class, DomainSocketAddress.class);
break;
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java
index 63fbef0cabe..75b51b3b2e5 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java
@@ -27,7 +27,6 @@
import io.grpc.benchmarks.proto.WorkerServiceGrpc;
import io.grpc.netty.NettyServerBuilder;
import io.grpc.stub.StreamObserver;
-import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -45,11 +44,13 @@ public class LoadWorker {
LoadWorker(int driverPort, int serverPort) throws Exception {
this.serverPort = serverPort;
- NioEventLoopGroup singleThreadGroup = new NioEventLoopGroup(1,
- new ThreadFactoryBuilder()
- .setDaemon(true)
- .setNameFormat("load-worker-%d")
- .build());
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ io.netty.channel.EventLoopGroup singleThreadGroup =
+ new io.netty.channel.nio.NioEventLoopGroup(1,
+ new ThreadFactoryBuilder()
+ .setDaemon(true)
+ .setNameFormat("load-worker-%d")
+ .build());
this.driverServer = NettyServerBuilder.forPort(driverPort, InsecureServerCredentials.create())
.directExecutor()
.channelType(NioServerSocketChannel.class)
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
index 7f61e15f783..9c7455ac45b 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
@@ -29,7 +29,6 @@
import io.grpc.testing.TlsTesting;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.ServerChannel;
-import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.util.concurrent.DefaultThreadFactory;
import java.io.IOException;
@@ -94,8 +93,12 @@ static Server newServer(ServerConfiguration config) throws IOException {
ThreadFactory tf = new DefaultThreadFactory("server-elg-", true /*daemon */);
switch (config.transport) {
case NETTY_NIO: {
- boss = new NioEventLoopGroup(1, tf);
- worker = new NioEventLoopGroup(0, tf);
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ EventLoopGroup nioBoss = new io.netty.channel.nio.NioEventLoopGroup(1, tf);
+ @SuppressWarnings("deprecation") // Wait a bit before migrating to the Netty 4.2 API
+ EventLoopGroup nioWorker = new io.netty.channel.nio.NioEventLoopGroup(0, tf);
+ boss = nioBoss;
+ worker = nioWorker;
channelType = NioServerSocketChannel.class;
break;
}
diff --git a/binder/BUILD.bazel b/binder/BUILD.bazel
new file mode 100644
index 00000000000..a0b8e9353e9
--- /dev/null
+++ b/binder/BUILD.bazel
@@ -0,0 +1,29 @@
+load("@rules_android//rules:rules.bzl", "android_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+licenses(["notice"])
+
+android_library(
+ name = "binder",
+ srcs = glob([
+ "src/main/java/**/*.java",
+ ]),
+ manifest = "src/main/AndroidManifest.xml",
+ custom_package = "io.grpc.binder",
+ # TODO(jdcormie): Figure out how to make this public without forcing
+ # existing non-android users to configure rules_android and Google's maven.
+ visibility = ["//:__subpackages__"],
+ exports = ["@grpc_android_maven//:androidx_annotation_annotation"],
+ deps = [
+ "//api",
+ "//core:internal",
+ # Resolve android deps from the isolated grpc_android_maven repository.
+ "@grpc_android_maven//:androidx_annotation_annotation",
+ "@grpc_android_maven//:androidx_annotation_annotation_jvm",
+ "@grpc_android_maven//:androidx_core_core",
+ "@grpc_android_maven//:androidx_lifecycle_lifecycle_common",
+ artifact("com.google.code.findbugs:jsr305"),
+ artifact("com.google.errorprone:error_prone_annotations"),
+ artifact("com.google.guava:guava"),
+ ],
+)
diff --git a/binder/build.gradle b/binder/build.gradle
index d1302ddfed0..7e7d4810e98 100644
--- a/binder/build.gradle
+++ b/binder/build.gradle
@@ -13,14 +13,20 @@ android {
targetCompatibility 1.8
}
defaultConfig {
- minSdkVersion 22
+ minSdkVersion 23
targetSdkVersion 33
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
- multiDexEnabled = true
}
lintOptions { abortOnError = false }
+ buildTypes {
+ debug {
+ testCoverageEnabled true // For robolectric unit tests.
+ enableUnitTestCoverage true // For tests that run on an emulator.
+ }
+ }
+
publishing {
singleVariant('release') {
withSourcesJar()
@@ -55,6 +61,7 @@ dependencies {
testImplementation project(':grpc-testing')
testImplementation project(':grpc-inprocess')
testImplementation testFixtures(project(':grpc-core'))
+ testImplementation testFixtures(project(':grpc-api'))
androidTestAnnotationProcessor libraries.auto.value
androidTestImplementation project(':grpc-testing')
@@ -134,3 +141,31 @@ afterEvaluate {
components.release.withVariantsFromConfiguration(configurations.releaseTestFixturesVariantReleaseApiPublication) { skip() }
components.release.withVariantsFromConfiguration(configurations.releaseTestFixturesVariantReleaseRuntimePublication) { skip() }
}
+
+tasks.withType(Test) {
+ // Robolectric modifies classes in memory at runtime, so they lack a java.security.CodeSource
+ // URL to their on-disk location. By default, JaCoCo ignores classes without this property.
+ // Overriding this allows Robolectric tests to be instrumented.
+ jacoco.includeNoLocationClasses = true
+ // Don't instrument certain JDK internals protected from modification by JEP 403's "strong
+ // encapsulation." Avoids IllegalAccessError, InvalidClassException and similar at runtime.
+ jacoco.excludes = ["jdk.internal.**"]
+}
+
+// Android projects don't automatically get a coverage report task. We must
+// register one manually here and wire it up to AGP's test tasks.
+tasks.register("jacocoTestReport", JacocoReport) {
+ dependsOn "testDebugUnitTest"
+
+ reports {
+ // For codecov.io and coveralls.
+ xml.required = true
+ // Use the same output location as the other subprojects.
+ html.outputLocation = layout.buildDirectory.dir("reports/jacoco/test/html")
+ }
+
+ sourceDirectories.from = android.sourceSets.main.java.srcDirs
+ classDirectories.from = fileTree(dir: layout.buildDirectory.dir("intermediates/javac/debug/classes"),
+ excludes: ['**/R.class', '**/R$*.class', '**/BuildConfig.class', '**/Manifest*.*', '**/*Test*.*', 'android/**/*.*'])
+ executionData.from = tasks.named("testDebugUnitTest").map { it.jacoco.destinationFile }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/BinderChannelSmokeTest.java b/binder/src/androidTest/java/io/grpc/binder/BinderChannelSmokeTest.java
index e3a8c58bf88..4e3cfcf0d05 100644
--- a/binder/src/androidTest/java/io/grpc/binder/BinderChannelSmokeTest.java
+++ b/binder/src/androidTest/java/io/grpc/binder/BinderChannelSmokeTest.java
@@ -97,6 +97,7 @@ public final class BinderChannelSmokeTest {
.setType(MethodDescriptor.MethodType.BIDI_STREAMING)
.build();
+ AndroidComponentAddress serverAddress;
ManagedChannel channel;
AtomicReference headersCapture = new AtomicReference<>();
AtomicReference clientUidCapture = new AtomicReference<>();
@@ -134,7 +135,7 @@ public void setUp() throws Exception {
TestUtils.recordRequestHeadersInterceptor(headersCapture),
PeerUids.newPeerIdentifyingServerInterceptor());
- AndroidComponentAddress serverAddress = HostServices.allocateService(appContext);
+ serverAddress = HostServices.allocateService(appContext);
HostServices.configureService(
serverAddress,
HostServices.serviceParamsBuilder()
@@ -149,13 +150,15 @@ public void setUp() throws Exception {
.build())
.build());
- channel =
- BinderChannelBuilder.forAddress(serverAddress, appContext)
+ channel = newBinderChannelBuilder().build();
+ }
+
+ BinderChannelBuilder newBinderChannelBuilder() {
+ return BinderChannelBuilder.forAddress(serverAddress, appContext)
.inboundParcelablePolicy(
- InboundParcelablePolicy.newBuilder()
- .setAcceptParcelableMetadataValues(true)
- .build())
- .build();
+ InboundParcelablePolicy.newBuilder()
+ .setAcceptParcelableMetadataValues(true)
+ .build());
}
@After
@@ -185,6 +188,18 @@ public void testBasicCall() throws Exception {
assertThat(doCall("Hello").get()).isEqualTo("Hello");
}
+ @Test
+ public void testBasicCallWithLegacyAuthStrategy() throws Exception {
+ channel = newBinderChannelBuilder().useLegacyAuthStrategy().build();
+ assertThat(doCall("Hello").get()).isEqualTo("Hello");
+ }
+
+ @Test
+ public void testBasicCallWithV2AuthStrategy() throws Exception {
+ channel = newBinderChannelBuilder().useV2AuthStrategy().build();
+ assertThat(doCall("Hello").get()).isEqualTo("Hello");
+ }
+
@Test
public void testPeerUidIsRecorded() throws Exception {
assertThat(doCall("Hello").get()).isEqualTo("Hello");
diff --git a/binder/src/androidTest/java/io/grpc/binder/internal/BinderClientTransportTest.java b/binder/src/androidTest/java/io/grpc/binder/internal/BinderClientTransportTest.java
index 0038a054854..aa3fb573ab5 100644
--- a/binder/src/androidTest/java/io/grpc/binder/internal/BinderClientTransportTest.java
+++ b/binder/src/androidTest/java/io/grpc/binder/internal/BinderClientTransportTest.java
@@ -41,6 +41,7 @@
import io.grpc.binder.BinderServerBuilder;
import io.grpc.binder.HostServices;
import io.grpc.binder.SecurityPolicy;
+import io.grpc.binder.internal.FakeDeadBinder;
import io.grpc.binder.internal.OneWayBinderProxies.BlackHoleOneWayBinderProxy;
import io.grpc.binder.internal.OneWayBinderProxies.BlockingBinderDecorator;
import io.grpc.binder.internal.OneWayBinderProxies.ThrowingOneWayBinderProxy;
@@ -48,6 +49,7 @@
import io.grpc.internal.ClientStream;
import io.grpc.internal.ClientStreamListener;
import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.DisconnectError;
import io.grpc.internal.FixedObjectPool;
import io.grpc.internal.ManagedClientTransport;
import io.grpc.internal.ObjectPool;
@@ -358,6 +360,20 @@ public void testTxnFailurePostSetup() throws Exception {
assertThat(streamStatus.getCause()).isSameInstanceAs(doe);
}
+ @Test
+ public void testServerBinderDeadOnArrival() throws Exception {
+ BlockingBinderDecorator decorator = new BlockingBinderDecorator<>();
+ transport = new BinderClientTransportBuilder().setBinderDecorator(decorator).build();
+ transport.start(transportListener).run();
+ decorator.putNextResult(decorator.takeNextRequest()); // Server's "Endpoint" Binder.
+ OneWayBinderProxy unusedServerBinder = decorator.takeNextRequest();
+ decorator.putNextResult(
+ OneWayBinderProxy.wrap(new FakeDeadBinder(), offloadServicePool.getObject()));
+ Status clientStatus = transportListener.awaitShutdown();
+ assertThat(clientStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+ assertThat(clientStatus.getDescription()).contains("Failed to observe outgoing binder");
+ }
+
@Test
public void testBlackHoleEndpointConnectTimeout() throws Exception {
BlockingBinderDecorator decorator = new BlockingBinderDecorator<>();
@@ -514,7 +530,7 @@ private static final class TestTransportListener implements ManagedClientTranspo
private final SettableFuture isTerminated = SettableFuture.create();
@Override
- public void transportShutdown(Status shutdownStatus) {
+ public void transportShutdown(Status shutdownStatus, DisconnectError disconnectError) {
if (!this.shutdownStatus.set(shutdownStatus)) {
throw new IllegalStateException("transportShutdown() already called");
}
diff --git a/binder/src/main/java/io/grpc/binder/BinderChannelBuilder.java b/binder/src/main/java/io/grpc/binder/BinderChannelBuilder.java
index 18928339fbd..a241634dd22 100644
--- a/binder/src/main/java/io/grpc/binder/BinderChannelBuilder.java
+++ b/binder/src/main/java/io/grpc/binder/BinderChannelBuilder.java
@@ -20,8 +20,6 @@
import static com.google.common.base.Preconditions.checkState;
import android.content.Context;
-import android.os.UserHandle;
-import androidx.annotation.RequiresApi;
import com.google.errorprone.annotations.DoNotCall;
import io.grpc.ExperimentalApi;
import io.grpc.ForwardingChannelBuilder;
@@ -235,32 +233,6 @@ public BinderChannelBuilder securityPolicy(SecurityPolicy securityPolicy) {
return this;
}
- /**
- * Specifies the {@link UserHandle} to be searched for the remote Android Service by default.
- *
- * Used only as a fallback if the direct or resolved {@link AndroidComponentAddress} doesn't
- * specify a {@link UserHandle}. If neither the Channel nor the {@link AndroidComponentAddress}
- * specifies a target user, the {@link UserHandle} of the current process will be used.
- *
- *
Connecting to a server in a different Android user is uncommon and can only be done by a
- * "system app" client with special permissions. See {@link
- * AndroidComponentAddress.Builder#setTargetUser(UserHandle)} for details.
- *
- * @deprecated This method's name is misleading because it implies an impersonated client identity
- * when it's actually specifying part of the server's location. It's also no longer necessary
- * since the target user is part of {@link AndroidComponentAddress}. Prefer to specify target
- * user in the address instead, either directly or via a {@link io.grpc.NameResolverProvider}.
- * @param targetUserHandle the target user to bind into.
- * @return this
- */
- @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10173")
- @RequiresApi(30)
- @Deprecated
- public BinderChannelBuilder bindAsUser(UserHandle targetUserHandle) {
- transportFactoryBuilder.setDefaultTargetUserHandle(targetUserHandle);
- return this;
- }
-
/** Sets the policy for inbound parcelable objects. */
public BinderChannelBuilder inboundParcelablePolicy(
InboundParcelablePolicy inboundParcelablePolicy) {
@@ -308,6 +280,67 @@ public BinderChannelBuilder preAuthorizeServers(boolean preAuthorize) {
return this;
}
+ /**
+ * Specifies how and when to authorize a server against this Channel's {@link SecurityPolicy}.
+ *
+ *
This method selects the original "legacy" authorization strategy, which is no longer
+ * preferred for two reasons: First, the legacy strategy considers the UID of the server *process*
+ * we connect to. This is problematic for services using the `android:isolatedProcess` attribute,
+ * which runs them under a different "ephemeral" UID. This UID lacks all the privileges of the
+ * hosting app -- any non-trivial SecurityPolicy would fail to authorize it. Second, the legacy
+ * authorization strategy performs SecurityPolicy checks later in the connection handshake, which
+ * means the calling UID must be rechecked on every subsequent RPC. For these reasons, prefer
+ * {@link #useV2AuthStrategy} instead.
+ *
+ *
The server does not know which authorization strategy a client is using. Both strategies
+ * work with all versions of the grpc-binder server.
+ *
+ *
Callers need not specify an authorization strategy, but the default is unspecified and will
+ * eventually become {@link #useV2AuthStrategy()}. Clients that require the legacy strategy should
+ * configure it explicitly using this method. Eventually, however, legacy support will be
+ * deprecated and removed.
+ *
+ * @return this
+ */
+ @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12397")
+ public BinderChannelBuilder useLegacyAuthStrategy() {
+ transportFactoryBuilder.setUseLegacyAuthStrategy(true);
+ return this;
+ }
+
+ /**
+ * Specifies how and when to authorize a server against this Channel's {@link SecurityPolicy}.
+ *
+ *
This method selects the v2 authorization strategy. It improves on the original strategy
+ * ({@link #useLegacyAuthStrategy}), by considering the UID of the server *app* we connect to,
+ * rather than the server *process*. This allows clients to connect to services configured with
+ * the `android:isolatedProcess` attribute, which run with the same authority as the hosting app,
+ * but under a different "ephemeral" UID that any non-trivial SecurityPolicy would fail to
+ * authorize.
+ *
+ *
Furthermore, the v2 authorization strategy performs SecurityPolicy checks earlier in the
+ * connection handshake, which allows subsequent RPCs over that connection to proceed securely
+ * without further UID checks. For these reasons, clients should prefer the v2 strategy.
+ *
+ *
The server does not know which authorization strategy a client is using. Both strategies
+ * work with all versions of the grpc-binder server.
+ *
+ *
Callers need not specify an authorization strategy, but the default is unspecified and can
+ * change over time. Clients that require the v2 strategy should configure it explicitly using
+ * this method. Eventually, this strategy will become the default and legacy support will be
+ * removed.
+ *
+ *
If moving to the new authorization strategy causes a robolectric test to fail, ensure your
+ * fake Service component is registered with `ShadowPackageManager` using `addOrUpdateService()`.
+ *
+ * @return this
+ */
+ @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12397")
+ public BinderChannelBuilder useV2AuthStrategy() {
+ transportFactoryBuilder.setUseLegacyAuthStrategy(false);
+ return this;
+ }
+
@Override
public BinderChannelBuilder idleTimeout(long value, TimeUnit unit) {
checkState(
diff --git a/binder/src/main/java/io/grpc/binder/BinderServerBuilder.java b/binder/src/main/java/io/grpc/binder/BinderServerBuilder.java
index c926c853472..5f0885883a5 100644
--- a/binder/src/main/java/io/grpc/binder/BinderServerBuilder.java
+++ b/binder/src/main/java/io/grpc/binder/BinderServerBuilder.java
@@ -68,7 +68,7 @@ private BinderServerBuilder(
serverImplBuilder =
new ServerImplBuilder(
- streamTracerFactories -> {
+ (streamTracerFactories, metricRecorder) -> {
internalBuilder.setStreamTracerFactories(streamTracerFactories);
BinderServer server = internalBuilder.build();
BinderInternal.setIBinder(binderReceiver, server.getHostBinder());
diff --git a/binder/src/main/java/io/grpc/binder/internal/Bindable.java b/binder/src/main/java/io/grpc/binder/internal/Bindable.java
index ae0c7284faf..59a2502de2b 100644
--- a/binder/src/main/java/io/grpc/binder/internal/Bindable.java
+++ b/binder/src/main/java/io/grpc/binder/internal/Bindable.java
@@ -54,8 +54,11 @@ interface Observer {
* before giving them a chance to run. However, note that the identity/existence of the resolved
* Service can change between the time this method returns and the time you actually bind/connect
* to it. For example, suppose the target package gets uninstalled or upgraded right after this
- * method returns. In {@link Observer#onBound}, you should verify that the server you resolved is
- * the same one you connected to.
+ * method returns.
+ *
+ *
Compare with {@link #getConnectedServiceInfo()}, which can only be called after {@link
+ * Observer#onBound(IBinder)} but can be used to learn about the service you actually connected
+ * to.
*/
@AnyThread
ServiceInfo resolve() throws StatusException;
@@ -68,6 +71,21 @@ interface Observer {
@AnyThread
void bind();
+ /**
+ * Asks PackageManager for details about the remote Service we *actually* connected to.
+ *
+ *
Can only be called after {@link Observer#onBound}.
+ *
+ *
Compare with {@link #resolve()}, which reports which service would be selected as of now but
+ * *without* connecting.
+ *
+ * @throws StatusException UNIMPLEMENTED if the connected service isn't found (an {@link
+ * Observer#onUnbound} callback has likely already happened or is on its way!)
+ * @throws IllegalStateException if {@link Observer#onBound} has not "happened-before" this call
+ */
+ @AnyThread
+ ServiceInfo getConnectedServiceInfo() throws StatusException;
+
/**
* Unbind from the remote service if connected.
*
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java
index 144ad56eec3..58e7d7e2b31 100644
--- a/binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java
@@ -25,6 +25,8 @@
import android.os.IBinder;
import android.os.Parcel;
import android.os.Process;
+import androidx.annotation.BinderThread;
+import androidx.annotation.MainThread;
import com.google.common.base.Ticker;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
@@ -54,6 +56,7 @@
import io.grpc.internal.GrpcUtil;
import io.grpc.internal.ManagedClientTransport;
import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SimpleDisconnectError;
import io.grpc.internal.StatsTraceContext;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledFuture;
@@ -72,6 +75,9 @@ public final class BinderClientTransport extends BinderTransport
private final SecurityPolicy securityPolicy;
private final Bindable serviceBinding;
+ @GuardedBy("this")
+ private final ClientHandshake handshake;
+
/** Number of ongoing calls which keep this transport "in-use". */
private final AtomicInteger numInUseStreams;
@@ -87,14 +93,6 @@ public final class BinderClientTransport extends BinderTransport
@GuardedBy("this")
private ScheduledFuture readyTimeoutFuture; // != null iff timeout scheduled.
- @GuardedBy("this")
- @Nullable
- private ListenableFuture authResultFuture; // null before we check auth.
-
- @GuardedBy("this")
- @Nullable
- private ListenableFuture preAuthResultFuture; // null before we pre-auth.
-
/**
* Constructs a new transport instance.
*
@@ -122,18 +120,17 @@ public BinderClientTransport(
Boolean preAuthServerOverride = options.getEagAttributes().get(PRE_AUTH_SERVER_OVERRIDE);
this.preAuthorizeServer =
preAuthServerOverride != null ? preAuthServerOverride : factory.preAuthorizeServers;
+ this.handshake =
+ factory.useLegacyAuthStrategy ? new LegacyClientHandshake() : new V2ClientHandshake();
numInUseStreams = new AtomicInteger();
pingTracker = new PingTracker(Ticker.systemTicker(), (id) -> sendPing(id));
-
serviceBinding =
new ServiceBinding(
factory.mainThreadExecutor,
factory.sourceContext,
factory.channelCredentials,
targetAddress.asBindIntent(),
- targetAddress.getTargetUser() != null
- ? targetAddress.getTargetUser()
- : factory.defaultTargetUserHandle,
+ targetAddress.getTargetUser(),
factory.bindServiceFlags.toInteger(),
this);
}
@@ -146,7 +143,7 @@ void releaseExecutors() {
@Override
public synchronized void onBound(IBinder binder) {
- sendSetupTransaction(binderDecorator.decorate(OneWayBinderProxy.wrap(binder, offloadExecutor)));
+ handshake.onBound(binderDecorator.decorate(OneWayBinderProxy.wrap(binder, offloadExecutor)));
}
@Override
@@ -158,31 +155,33 @@ public synchronized void onUnbound(Status reason) {
@Override
public synchronized Runnable start(Listener clientTransportListener) {
this.clientTransportListener = checkNotNull(clientTransportListener);
- return () -> {
- synchronized (BinderClientTransport.this) {
- if (inState(TransportState.NOT_STARTED)) {
- setState(TransportState.SETUP);
- try {
- if (preAuthorizeServer) {
- preAuthorize(serviceBinding.resolve());
- } else {
- serviceBinding.bind();
- }
- } catch (StatusException e) {
- shutdownInternal(e.getStatus(), true);
- return;
- }
- if (readyTimeoutMillis >= 0) {
- readyTimeoutFuture =
- getScheduledExecutorService()
- .schedule(
- BinderClientTransport.this::onReadyTimeout,
- readyTimeoutMillis,
- MILLISECONDS);
- }
- }
+ return this::postStartRunnable;
+ }
+
+ private synchronized void postStartRunnable() {
+ if (!inState(TransportState.NOT_STARTED)) {
+ return;
+ }
+
+ setState(TransportState.SETUP);
+
+ try {
+ if (preAuthorizeServer) {
+ preAuthorize(serviceBinding.resolve());
+ } else {
+ serviceBinding.bind();
}
- };
+ } catch (StatusException e) {
+ shutdownInternal(e.getStatus(), true);
+ return;
+ }
+
+ if (readyTimeoutMillis >= 0) {
+ readyTimeoutFuture =
+ getScheduledExecutorService()
+ .schedule(
+ BinderClientTransport.this::onReadyTimeout, readyTimeoutMillis, MILLISECONDS);
+ }
}
@GuardedBy("this")
@@ -195,7 +194,8 @@ private void preAuthorize(ServiceInfo serviceInfo) {
// unauthorized server a chance to run, but the connection will still fail by SecurityPolicy
// check later in handshake. Pre-auth remains effective at mitigating abuse because malware
// can't typically control the exact timing of its installation.
- preAuthResultFuture = checkServerAuthorizationAsync(serviceInfo.applicationInfo.uid);
+ ListenableFuture preAuthResultFuture =
+ register(checkServerAuthorizationAsync(serviceInfo.applicationInfo.uid));
Futures.addCallback(
preAuthResultFuture,
new FutureCallback() {
@@ -213,13 +213,16 @@ public void onFailure(Throwable t) {
}
private synchronized void handlePreAuthResult(Status authorization) {
- if (inState(TransportState.SETUP)) {
- if (!authorization.isOk()) {
- shutdownInternal(authorization, true);
- } else {
- serviceBinding.bind();
- }
+ if (!inState(TransportState.SETUP)) {
+ return;
+ }
+
+ if (!authorization.isOk()) {
+ shutdownInternal(authorization, true);
+ return;
}
+
+ serviceBinding.bind();
}
private synchronized void onReadyTimeout() {
@@ -261,22 +264,22 @@ public synchronized ClientStream newStream(
Status failure = Status.INTERNAL.withDescription("Clashing call IDs");
shutdownInternal(failure, true);
return newFailingClientStream(failure, attributes, headers, tracers);
+ }
+
+ if (inbound.countsForInUse() && numInUseStreams.getAndIncrement() == 0) {
+ clientTransportListener.transportInUse(true);
+ }
+ Outbound.ClientOutbound outbound =
+ new Outbound.ClientOutbound(this, callId, method, headers, statsTraceContext);
+ if (method.getType().clientSendsOneMessage()) {
+ return new SingleMessageClientStream(inbound, outbound, attributes);
} else {
- if (inbound.countsForInUse() && numInUseStreams.getAndIncrement() == 0) {
- clientTransportListener.transportInUse(true);
- }
- Outbound.ClientOutbound outbound =
- new Outbound.ClientOutbound(this, callId, method, headers, statsTraceContext);
- if (method.getType().clientSendsOneMessage()) {
- return new SingleMessageClientStream(inbound, outbound, attributes);
- } else {
- return new MultiMessageClientStream(inbound, outbound, attributes);
- }
+ return new MultiMessageClientStream(inbound, outbound, attributes);
}
}
@Override
- protected void unregisterInbound(Inbound inbound) {
+ protected void unregisterInbound(Inbound inbound) {
if (inbound.countsForInUse() && numInUseStreams.decrementAndGet() == 0) {
clientTransportListener.transportInUse(false);
}
@@ -303,7 +306,7 @@ public synchronized void shutdownNow(Status reason) {
@Override
@GuardedBy("this")
void notifyShutdown(Status status) {
- clientTransportListener.transportShutdown(status);
+ clientTransportListener.transportShutdown(status, SimpleDisconnectError.UNKNOWN);
}
@Override
@@ -316,12 +319,6 @@ void notifyTerminated() {
readyTimeoutFuture.cancel(false);
readyTimeoutFuture = null;
}
- if (preAuthResultFuture != null) {
- preAuthResultFuture.cancel(false); // No effect if already complete.
- }
- if (authResultFuture != null) {
- authResultFuture.cancel(false); // No effect if already complete.
- }
serviceBinding.unbind();
clientTransportListener.transportTerminated();
}
@@ -329,35 +326,47 @@ void notifyTerminated() {
@Override
@GuardedBy("this")
protected void handleSetupTransport(Parcel parcel) {
- int remoteUid = Binder.getCallingUid();
- if (inState(TransportState.SETUP)) {
- int version = parcel.readInt();
- IBinder binder = parcel.readStrongBinder();
- if (version != WIRE_FORMAT_VERSION) {
- shutdownInternal(Status.UNAVAILABLE.withDescription("Wire format version mismatch"), true);
- } else if (binder == null) {
- shutdownInternal(
- Status.UNAVAILABLE.withDescription("Malformed SETUP_TRANSPORT data"), true);
- } else {
- restrictIncomingBinderToCallsFrom(remoteUid);
- attributes = setSecurityAttrs(attributes, remoteUid);
- authResultFuture = checkServerAuthorizationAsync(remoteUid);
- Futures.addCallback(
- authResultFuture,
- new FutureCallback() {
- @Override
- public void onSuccess(Status result) {
- handleAuthResult(binder, result);
- }
+ if (!inState(TransportState.SETUP)) {
+ return;
+ }
- @Override
- public void onFailure(Throwable t) {
- handleAuthResult(t);
- }
- },
- offloadExecutor);
- }
+ int version = parcel.readInt();
+ if (version != WIRE_FORMAT_VERSION) {
+ shutdownInternal(Status.UNAVAILABLE.withDescription("Wire format version mismatch"), true);
+ return;
+ }
+
+ IBinder binder = parcel.readStrongBinder();
+ if (binder == null) {
+ shutdownInternal(Status.UNAVAILABLE.withDescription("Malformed SETUP_TRANSPORT data"), true);
+ return;
+ }
+
+ if (!setOutgoingBinder(OneWayBinderProxy.wrap(binder, offloadExecutor))) {
+ shutdownInternal(
+ Status.UNAVAILABLE.withDescription("Failed to observe outgoing binder"), true);
+ return;
}
+ handshake.handleSetupTransport();
+ }
+
+ @GuardedBy("this")
+ private void checkServerAuthorization(int remoteUid) {
+ ListenableFuture authResultFuture = register(checkServerAuthorizationAsync(remoteUid));
+ Futures.addCallback(
+ authResultFuture,
+ new FutureCallback() {
+ @Override
+ public void onSuccess(Status result) {
+ handleAuthResult(result);
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ handleAuthResult(t);
+ }
+ },
+ offloadExecutor);
}
private ListenableFuture checkServerAuthorizationAsync(int remoteUid) {
@@ -366,26 +375,76 @@ private ListenableFuture checkServerAuthorizationAsync(int remoteUid) {
: Futures.submit(() -> securityPolicy.checkAuthorization(remoteUid), offloadExecutor);
}
- private synchronized void handleAuthResult(IBinder binder, Status authorization) {
- if (inState(TransportState.SETUP)) {
- if (!authorization.isOk()) {
- shutdownInternal(authorization, true);
- } else if (!setOutgoingBinder(OneWayBinderProxy.wrap(binder, offloadExecutor))) {
- shutdownInternal(
- Status.UNAVAILABLE.withDescription("Failed to observe outgoing binder"), true);
- } else {
- // Check state again, since a failure inside setOutgoingBinder (or a callback it
- // triggers), could have shut us down.
- if (!isShutdown()) {
- setState(TransportState.READY);
- attributes = clientTransportListener.filterTransport(attributes);
- clientTransportListener.transportReady();
- if (readyTimeoutFuture != null) {
- readyTimeoutFuture.cancel(false);
- readyTimeoutFuture = null;
- }
- }
+ private synchronized void handleAuthResult(Status authorization) {
+ if (!inState(TransportState.SETUP)) {
+ return;
+ }
+
+ if (!authorization.isOk()) {
+ shutdownInternal(authorization, true);
+ return;
+ }
+ handshake.onServerAuthorizationOk();
+ }
+
+ private final class V2ClientHandshake implements ClientHandshake {
+
+ private OneWayBinderProxy endpointBinder;
+
+ @Override
+ @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+ public void onBound(OneWayBinderProxy endpointBinder) {
+ this.endpointBinder = endpointBinder;
+ Futures.addCallback(
+ Futures.submit(serviceBinding::getConnectedServiceInfo, offloadExecutor),
+ new FutureCallback() {
+ @Override
+ public void onSuccess(ServiceInfo result) {
+ synchronized (BinderClientTransport.this) {
+ onConnectedServiceInfo(result);
+ }
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ synchronized (BinderClientTransport.this) {
+ shutdownInternal(Status.fromThrowable(t), true);
+ }
+ }
+ },
+ offloadExecutor);
+ }
+
+ @GuardedBy("BinderClientTransport.this")
+ private void onConnectedServiceInfo(ServiceInfo serviceInfo) {
+ if (!inState(TransportState.SETUP)) {
+ return;
}
+ attributes = setSecurityAttrs(attributes, serviceInfo.applicationInfo.uid);
+ checkServerAuthorization(serviceInfo.applicationInfo.uid);
+ }
+
+ @Override
+ @GuardedBy("BinderClientTransport.this")
+ public void onServerAuthorizationOk() {
+ sendSetupTransaction(endpointBinder);
+ }
+
+ @Override
+ @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+ public void handleSetupTransport() {
+ onHandshakeComplete();
+ }
+ }
+
+ @GuardedBy("this")
+ private void onHandshakeComplete() {
+ setState(TransportState.READY);
+ attributes = clientTransportListener.filterTransport(attributes);
+ clientTransportListener.transportReady();
+ if (readyTimeoutFuture != null) {
+ readyTimeoutFuture.cancel(false);
+ readyTimeoutFuture = null;
}
}
@@ -400,6 +459,52 @@ protected void handlePingResponse(Parcel parcel) {
pingTracker.onPingResponse(parcel.readInt());
}
+ /**
+ * An abstract implementation of the client's connection handshake.
+ *
+ * Supports a clean migration away from the legacy approach, one client at a time.
+ */
+ private interface ClientHandshake {
+ /**
+ * Notifies the implementation that the binding has succeeded and we are now connected to the
+ * server's "endpoint" which can be reached at 'endpointBinder'.
+ */
+ @MainThread
+ void onBound(OneWayBinderProxy endpointBinder);
+
+ /** Notifies the implementation that we've received a valid SETUP_TRANSPORT transaction. */
+ @BinderThread
+ void handleSetupTransport();
+
+ /** Notifies the implementation that the SecurityPolicy check of the server succeeded. */
+ void onServerAuthorizationOk();
+ }
+
+ private final class LegacyClientHandshake implements ClientHandshake {
+ @Override
+ @MainThread
+ @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+ public void onBound(OneWayBinderProxy binder) {
+ sendSetupTransaction(binder);
+ }
+
+ @Override
+ @BinderThread
+ @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+ public void handleSetupTransport() {
+ int remoteUid = Binder.getCallingUid();
+ restrictIncomingBinderToCallsFrom(remoteUid);
+ attributes = setSecurityAttrs(attributes, remoteUid);
+ checkServerAuthorization(remoteUid);
+ }
+
+ @Override
+ @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+ public void onServerAuthorizationOk() {
+ onHandshakeComplete();
+ }
+ }
+
private static ClientStream newFailingClientStream(
Status failure, Attributes attributes, Metadata headers, ClientStreamTracer[] tracers) {
StatsTraceContext statsTraceContext =
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderClientTransportFactory.java b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransportFactory.java
index 3f51452c90c..459e064ad9b 100644
--- a/binder/src/main/java/io/grpc/binder/internal/BinderClientTransportFactory.java
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransportFactory.java
@@ -18,7 +18,6 @@
import static com.google.common.base.Preconditions.checkNotNull;
import android.content.Context;
-import android.os.UserHandle;
import androidx.core.content.ContextCompat;
import io.grpc.ChannelCredentials;
import io.grpc.ChannelLogger;
@@ -39,7 +38,6 @@
import java.util.Collections;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
-import javax.annotation.Nullable;
/** Creates new binder transports. */
@Internal
@@ -50,12 +48,12 @@ public final class BinderClientTransportFactory implements ClientTransportFactor
final ObjectPool scheduledExecutorPool;
final ObjectPool offloadExecutorPool;
final SecurityPolicy securityPolicy;
- @Nullable final UserHandle defaultTargetUserHandle;
final BindServiceFlags bindServiceFlags;
final InboundParcelablePolicy inboundParcelablePolicy;
final OneWayBinderProxy.Decorator binderDecorator;
final long readyTimeoutMillis;
final boolean preAuthorizeServers; // TODO(jdcormie): Default to true.
+ final boolean useLegacyAuthStrategy;
ScheduledExecutorService executorService;
Executor offloadExecutor;
@@ -71,12 +69,12 @@ private BinderClientTransportFactory(Builder builder) {
scheduledExecutorPool = checkNotNull(builder.scheduledExecutorPool);
offloadExecutorPool = checkNotNull(builder.offloadExecutorPool);
securityPolicy = checkNotNull(builder.securityPolicy);
- defaultTargetUserHandle = builder.defaultTargetUserHandle;
bindServiceFlags = checkNotNull(builder.bindServiceFlags);
inboundParcelablePolicy = checkNotNull(builder.inboundParcelablePolicy);
binderDecorator = checkNotNull(builder.binderDecorator);
readyTimeoutMillis = builder.readyTimeoutMillis;
preAuthorizeServers = builder.preAuthorizeServers;
+ useLegacyAuthStrategy = builder.useLegacyAuthStrategy;
executorService = scheduledExecutorPool.getObject();
offloadExecutor = offloadExecutorPool.getObject();
@@ -125,12 +123,12 @@ public static final class Builder implements ClientTransportFactoryBuilder {
ObjectPool scheduledExecutorPool =
SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
SecurityPolicy securityPolicy = SecurityPolicies.internalOnly();
- @Nullable UserHandle defaultTargetUserHandle;
BindServiceFlags bindServiceFlags = BindServiceFlags.DEFAULTS;
InboundParcelablePolicy inboundParcelablePolicy = InboundParcelablePolicy.DEFAULT;
OneWayBinderProxy.Decorator binderDecorator = OneWayBinderProxy.IDENTITY_DECORATOR;
long readyTimeoutMillis = 60_000;
boolean preAuthorizeServers;
+ boolean useLegacyAuthStrategy = true; // TODO(jdcormie): Default to false.
@Override
public BinderClientTransportFactory buildClientTransportFactory() {
@@ -172,11 +170,6 @@ public Builder setSecurityPolicy(SecurityPolicy securityPolicy) {
return this;
}
- public Builder setDefaultTargetUserHandle(@Nullable UserHandle defaultTargetUserHandle) {
- this.defaultTargetUserHandle = defaultTargetUserHandle;
- return this;
- }
-
public Builder setBindServiceFlags(BindServiceFlags bindServiceFlags) {
this.bindServiceFlags = checkNotNull(bindServiceFlags, "bindServiceFlags");
return this;
@@ -229,5 +222,11 @@ public Builder setPreAuthorizeServers(boolean preAuthorizeServers) {
this.preAuthorizeServers = preAuthorizeServers;
return this;
}
+
+ /** Specifies which version of the client handshake to use. */
+ public Builder setUseLegacyAuthStrategy(boolean useLegacyAuthStrategy) {
+ this.useLegacyAuthStrategy = useLegacyAuthStrategy;
+ return this;
+ }
}
}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderServer.java b/binder/src/main/java/io/grpc/binder/internal/BinderServer.java
index fca8e3d88e1..f913775fcbe 100644
--- a/binder/src/main/java/io/grpc/binder/internal/BinderServer.java
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderServer.java
@@ -70,6 +70,7 @@ public final class BinderServer implements InternalServer, LeakSafeOneWayBinder.
private final LeakSafeOneWayBinder hostServiceBinder;
private final BinderTransportSecurity.ServerPolicyChecker serverPolicyChecker;
private final InboundParcelablePolicy inboundParcelablePolicy;
+ private final OneWayBinderProxy.Decorator clientBinderDecorator;
@GuardedBy("this")
private ServerListener listener;
@@ -92,6 +93,7 @@ private BinderServer(Builder builder) {
ImmutableList.copyOf(checkNotNull(builder.streamTracerFactories, "streamTracerFactories"));
this.serverPolicyChecker = BinderInternal.createPolicyChecker(builder.serverSecurityPolicy);
this.inboundParcelablePolicy = builder.inboundParcelablePolicy;
+ this.clientBinderDecorator = builder.clientBinderDecorator;
hostServiceBinder = new LeakSafeOneWayBinder(this);
}
@@ -179,13 +181,13 @@ public synchronized boolean handleTransaction(int code, Parcel parcel) {
checkNotNull(executor, "Not started?"));
// Create a new transport and let our listener know about it.
BinderServerTransport transport =
- new BinderServerTransport(
+ BinderServerTransport.create(
executorServicePool,
attrsBuilder.build(),
streamTracerFactories,
- OneWayBinderProxy.IDENTITY_DECORATOR,
+ clientBinderDecorator,
callbackBinder);
- transport.setServerTransportListener(listener.transportCreated(transport));
+ transport.start(listener.transportCreated(transport));
return true;
}
}
@@ -225,6 +227,7 @@ public static class Builder {
SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
ServerSecurityPolicy serverSecurityPolicy = SecurityPolicies.serverInternalOnly();
InboundParcelablePolicy inboundParcelablePolicy = InboundParcelablePolicy.DEFAULT;
+ OneWayBinderProxy.Decorator clientBinderDecorator = OneWayBinderProxy.IDENTITY_DECORATOR;
public BinderServer build() {
return new BinderServer(this);
@@ -295,5 +298,19 @@ public Builder setInboundParcelablePolicy(InboundParcelablePolicy inboundParcela
checkNotNull(inboundParcelablePolicy, "inboundParcelablePolicy");
return this;
}
+
+ /**
+ * Sets the {@link OneWayBinderProxy.Decorator} to be applied to this server's "client Binders".
+ *
+ * Tests can use this to capture post-setup transactions from server to client. The specified
+ * decorator will be applied every time a client connects. The decorated result will be used for
+ * all subsequent transactions to this client from the new ServerTransport.
+ *
+ *
Optional, {@link OneWayBinderProxy#IDENTITY_DECORATOR} is the default.
+ */
+ public Builder setClientBinderDecorator(OneWayBinderProxy.Decorator clientBinderDecorator) {
+ this.clientBinderDecorator = checkNotNull(clientBinderDecorator);
+ return this;
+ }
}
}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java b/binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java
index 1c345249735..784d833bdf5 100644
--- a/binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java
@@ -38,54 +38,87 @@
public final class BinderServerTransport extends BinderTransport implements ServerTransport {
private final List streamTracerFactories;
- @Nullable private ServerTransportListener serverTransportListener;
+
+ @GuardedBy("this")
+ private final SimplePromise listenerPromise = new SimplePromise<>();
+
+ private BinderServerTransport(
+ ObjectPool executorServicePool,
+ Attributes attributes,
+ List streamTracerFactories,
+ OneWayBinderProxy.Decorator binderDecorator) {
+ super(executorServicePool, attributes, binderDecorator, buildLogId(attributes));
+ this.streamTracerFactories = streamTracerFactories;
+ }
/**
* Constructs a new transport instance.
*
* @param binderDecorator used to decorate 'callbackBinder', for fault injection.
*/
- public BinderServerTransport(
+ public static BinderServerTransport create(
ObjectPool executorServicePool,
Attributes attributes,
List streamTracerFactories,
OneWayBinderProxy.Decorator binderDecorator,
IBinder callbackBinder) {
- super(executorServicePool, attributes, binderDecorator, buildLogId(attributes));
- this.streamTracerFactories = streamTracerFactories;
+ BinderServerTransport transport =
+ new BinderServerTransport(
+ executorServicePool, attributes, streamTracerFactories, binderDecorator);
// TODO(jdcormie): Plumb in the Server's executor() and use it here instead.
- setOutgoingBinder(OneWayBinderProxy.wrap(callbackBinder, getScheduledExecutorService()));
+ // No need to handle failure here because if 'callbackBinder' is already dead, we'll notice it
+ // again in start() when we send the first transaction.
+ synchronized (transport) {
+ transport.setOutgoingBinder(
+ OneWayBinderProxy.wrap(callbackBinder, transport.getScheduledExecutorService()));
+ }
+ return transport;
}
- public synchronized void setServerTransportListener(
- ServerTransportListener serverTransportListener) {
- this.serverTransportListener = serverTransportListener;
+ /**
+ * Initializes this transport instance.
+ *
+ * Must be called exactly once, even if {@link #shutdown} or {@link #shutdownNow} was called
+ * first.
+ *
+ * @param serverTransportListener where this transport will report events
+ */
+ public synchronized void start(ServerTransportListener serverTransportListener) {
+ this.listenerPromise.set(serverTransportListener);
+ if (isShutdown()) {
+ // It's unlikely, but we could be shutdown externally between construction and start(). One
+ // possible cause is an extremely short handshake timeout.
+ return;
+ }
+
+ sendSetupTransaction();
+
+ // Check we're not shutdown again, since a failure inside sendSetupTransaction (or a callback
+ // it triggers), could have shut us down.
if (isShutdown()) {
- setState(TransportState.SHUTDOWN_TERMINATED);
- notifyTerminated();
- releaseExecutors();
- } else {
- sendSetupTransaction();
- // Check we're not shutdown again, since a failure inside sendSetupTransaction (or a callback
- // it triggers), could have shut us down.
- if (!isShutdown()) {
- setState(TransportState.READY);
- attributes = serverTransportListener.transportReady(attributes);
- }
+ return;
}
+
+ setState(TransportState.READY);
+ attributes = serverTransportListener.transportReady(attributes);
}
StatsTraceContext createStatsTraceContext(String methodName, Metadata headers) {
return StatsTraceContext.newServerContext(streamTracerFactories, methodName, headers);
}
+ /**
+ * Reports a new ServerStream requested by the remote client.
+ *
+ *
Precondition: {@link #start(ServerTransportListener)} must already have been called.
+ */
synchronized Status startStream(ServerStream stream, String methodName, Metadata headers) {
if (isShutdown()) {
return Status.UNAVAILABLE.withDescription("transport is shutdown");
- } else {
- serverTransportListener.streamCreated(stream, methodName, headers);
- return Status.OK;
}
+
+ listenerPromise.get().streamCreated(stream, methodName, headers);
+ return Status.OK;
}
@Override
@@ -97,9 +130,7 @@ void notifyShutdown(Status status) {
@Override
@GuardedBy("this")
void notifyTerminated() {
- if (serverTransportListener != null) {
- serverTransportListener.transportTerminated();
- }
+ listenerPromise.runWhenSet(ServerTransportListener::transportTerminated);
}
@Override
@@ -115,7 +146,7 @@ public synchronized void shutdownNow(Status reason) {
@Override
@Nullable
@GuardedBy("this")
- protected Inbound createInbound(int callId) {
+ protected Inbound createInbound(int callId) {
return new Inbound.ServerInbound(this, attributes, callId);
}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderTransport.java b/binder/src/main/java/io/grpc/binder/internal/BinderTransport.java
index 904b7e83001..2b7aa97bfd9 100644
--- a/binder/src/main/java/io/grpc/binder/internal/BinderTransport.java
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderTransport.java
@@ -45,14 +45,15 @@
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
+import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
/**
* Base class for binder-based gRPC transport.
@@ -74,8 +75,9 @@
*
*
IMPORTANT: This implementation must comply with this published wire format.
* https://github.com/grpc/proposal/blob/master/L73-java-binderchannel/wireformat.md
+ *
+ *
This class is thread-safe.
*/
-@ThreadSafe
public abstract class BinderTransport implements IBinder.DeathRecipient {
private static final Logger logger = Logger.getLogger(BinderTransport.class.getName());
@@ -157,15 +159,19 @@ protected enum TransportState {
private final ObjectPool executorServicePool;
private final ScheduledExecutorService scheduledExecutorService;
private final InternalLogId logId;
+
@GuardedBy("this")
private final LeakSafeOneWayBinder incomingBinder;
- protected final ConcurrentHashMap> ongoingCalls;
+ protected final ConcurrentHashMap> ongoingCalls;
protected final OneWayBinderProxy.Decorator binderDecorator;
@GuardedBy("this")
private final LinkedHashSet callIdsToNotifyWhenReady = new LinkedHashSet<>();
+ @GuardedBy("this")
+ private final List> ownedFutures = new ArrayList<>(); // To cancel upon terminate.
+
@GuardedBy("this")
protected Attributes attributes;
@@ -249,6 +255,13 @@ void releaseExecutors() {
executorServicePool.returnObject(scheduledExecutorService);
}
+ // Registers the specified future for eventual safe cancellation upon shutdown/terminate.
+ @GuardedBy("this")
+ protected final > T register(T future) {
+ ownedFutures.add(future);
+ return future;
+ }
+
@GuardedBy("this")
boolean inState(TransportState transportState) {
return this.transportState == transportState;
@@ -265,6 +278,14 @@ final void setState(TransportState newState) {
transportState = newState;
}
+ /**
+ * Sets the binder to use for sending subsequent transactions to our peer.
+ *
+ * Subclasses should call this as early as possible but not from a constructor.
+ *
+ *
Returns true for success, false if the process hosting 'binder' is already dead. Callers are
+ * responsible for handling this.
+ */
@GuardedBy("this")
protected boolean setOutgoingBinder(OneWayBinderProxy binder) {
binder = binderDecorator.decorate(binder);
@@ -297,15 +318,23 @@ final void shutdownInternal(Status shutdownStatus, boolean forceTerminate) {
incomingBinder.detach();
setState(TransportState.SHUTDOWN_TERMINATED);
sendShutdownTransaction();
- ArrayList> calls = new ArrayList<>(ongoingCalls.values());
+ ArrayList> calls = new ArrayList<>(ongoingCalls.values());
ongoingCalls.clear();
+ ArrayList> futuresToCancel = new ArrayList<>(ownedFutures);
+ ownedFutures.clear();
scheduledExecutorService.execute(
() -> {
- for (Inbound inbound : calls) {
+ for (Inbound inbound : calls) {
synchronized (inbound) {
inbound.closeAbnormal(shutdownStatus);
}
}
+
+ for (Future future : futuresToCancel) {
+ // Not holding any locks here just in case some listener runs on a direct Executor.
+ future.cancel(false); // No effect if already isDone().
+ }
+
synchronized (this) {
notifyTerminated();
}
@@ -363,7 +392,7 @@ protected synchronized void sendPing(int id) throws StatusException {
}
}
- protected void unregisterInbound(Inbound inbound) {
+ protected void unregisterInbound(Inbound inbound) {
unregisterCall(inbound.callId);
}
@@ -452,13 +481,13 @@ private boolean handleTransactionInternal(int code, Parcel parcel) {
}
} else {
int size = parcel.dataSize();
- Inbound inbound = ongoingCalls.get(code);
+ Inbound inbound = ongoingCalls.get(code);
if (inbound == null) {
synchronized (this) {
if (!isShutdown()) {
inbound = createInbound(code);
if (inbound != null) {
- Inbound existing = ongoingCalls.put(code, inbound);
+ Inbound existing = ongoingCalls.put(code, inbound);
// Can't happen as only one invocation of handleTransaction() is running at a time.
Verify.verify(existing == null, "impossible appearance of %s", existing);
}
@@ -490,7 +519,7 @@ protected void restrictIncomingBinderToCallsFrom(int allowedCallingUid) {
@Nullable
@GuardedBy("this")
- protected Inbound createInbound(int callId) {
+ protected Inbound createInbound(int callId) {
return null;
}
@@ -537,7 +566,7 @@ final void handleAcknowledgedBytes(long numBytes) {
Iterator i = callIdsToNotifyWhenReady.iterator();
while (isReady() && i.hasNext()) {
- Inbound inbound = ongoingCalls.get(i.next());
+ Inbound inbound = ongoingCalls.get(i.next());
i.remove();
if (inbound != null) { // Calls can be removed out from under us.
inbound.onTransportReady();
@@ -569,7 +598,7 @@ private static void checkTransition(TransportState current, TransportState next)
}
@VisibleForTesting
- Map> getOngoingCalls() {
+ Map> getOngoingCalls() {
return ongoingCalls;
}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BlockPool.java b/binder/src/main/java/io/grpc/binder/internal/BlockPool.java
index 3c58abdd80b..985e465ab4b 100644
--- a/binder/src/main/java/io/grpc/binder/internal/BlockPool.java
+++ b/binder/src/main/java/io/grpc/binder/internal/BlockPool.java
@@ -40,7 +40,7 @@ final class BlockPool {
* The size of each standard block. (Currently 16k) The block size must be at least as large as
* the maximum header list size.
*/
- private static final int BLOCK_SIZE = Math.max(16 * 1024, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE);
+ static final int BLOCK_SIZE = Math.max(16 * 1024, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE);
/**
* Maximum number of blocks to keep around. (Max 128k). This limit is a judgement call. 128k is
diff --git a/binder/src/main/java/io/grpc/binder/internal/Inbound.java b/binder/src/main/java/io/grpc/binder/internal/Inbound.java
index 9b9dfeef5ce..83fc8273d6f 100644
--- a/binder/src/main/java/io/grpc/binder/internal/Inbound.java
+++ b/binder/src/main/java/io/grpc/binder/internal/Inbound.java
@@ -42,9 +42,10 @@
*
* Out-of-order messages are reassembled into their correct order.
*/
-abstract class Inbound implements StreamListener.MessageProducer {
+abstract class Inbound
+ implements StreamListener.MessageProducer {
- protected final BinderTransport transport;
+ protected final T transport;
protected final Attributes attributes;
final int callId;
@@ -145,7 +146,7 @@ enum State {
@GuardedBy("this")
private boolean producingMessages;
- private Inbound(BinderTransport transport, Attributes attributes, int callId) {
+ private Inbound(T transport, Attributes attributes, int callId) {
this.transport = transport;
this.attributes = attributes;
this.callId = callId;
@@ -399,6 +400,13 @@ private void handleMessageData(int flags, int index, Parcel parcel) throws Statu
numBytes = parcel.dataPosition() - startPos;
} else {
numBytes = parcel.readInt();
+ if (numBytes > parcel.dataAvail()) {
+ throw Status.INTERNAL
+ .withDescription(
+ "Message size is larger than remaining parcel size: "
+ + numBytes + " > " + parcel.dataAvail())
+ .asException();
+ }
block = BlockPool.acquireBlock(numBytes);
if (numBytes > 0) {
parcel.readByteArray(block);
@@ -551,7 +559,7 @@ public synchronized String toString() {
// ======================================
// Client-side inbound transactions.
- static final class ClientInbound extends Inbound {
+ static final class ClientInbound extends Inbound {
private final boolean countsForInUse;
@@ -564,7 +572,10 @@ static final class ClientInbound extends Inbound {
private Metadata trailers;
ClientInbound(
- BinderTransport transport, Attributes attributes, int callId, boolean countsForInUse) {
+ BinderClientTransport transport,
+ Attributes attributes,
+ int callId,
+ boolean countsForInUse) {
super(transport, attributes, callId);
this.countsForInUse = countsForInUse;
}
@@ -608,13 +619,9 @@ protected void deliverCloseAbnormal(Status status) {
// ======================================
// Server-side inbound transactions.
- static final class ServerInbound extends Inbound {
-
- private final BinderServerTransport serverTransport;
-
+ static final class ServerInbound extends Inbound {
ServerInbound(BinderServerTransport transport, Attributes attributes, int callId) {
super(transport, attributes, callId);
- this.serverTransport = transport;
}
@GuardedBy("this")
@@ -623,17 +630,16 @@ protected void handlePrefix(int flags, Parcel parcel) throws StatusException {
String methodName = parcel.readString();
Metadata headers = MetadataHelper.readMetadata(parcel, attributes);
- StatsTraceContext statsTraceContext =
- serverTransport.createStatsTraceContext(methodName, headers);
+ StatsTraceContext statsTraceContext = transport.createStatsTraceContext(methodName, headers);
Outbound.ServerOutbound outbound =
- new Outbound.ServerOutbound(serverTransport, callId, statsTraceContext);
+ new Outbound.ServerOutbound(transport, callId, statsTraceContext);
ServerStream stream;
if ((flags & TransactionUtils.FLAG_EXPECT_SINGLE_MESSAGE) != 0) {
stream = new SingleMessageServerStream(this, outbound, attributes);
} else {
stream = new MultiMessageServerStream(this, outbound, attributes);
}
- Status status = serverTransport.startStream(stream, methodName, headers);
+ Status status = transport.startStream(stream, methodName, headers);
if (status.isOk()) {
checkNotNull(listener); // Is it ok to assume this will happen synchronously?
if (transport.isReady()) {
diff --git a/binder/src/main/java/io/grpc/binder/internal/IntentNameResolverProvider.java b/binder/src/main/java/io/grpc/binder/internal/IntentNameResolverProvider.java
index 67859045dba..5a3c9fcc986 100644
--- a/binder/src/main/java/io/grpc/binder/internal/IntentNameResolverProvider.java
+++ b/binder/src/main/java/io/grpc/binder/internal/IntentNameResolverProvider.java
@@ -20,6 +20,7 @@
import android.content.Intent;
import com.google.common.collect.ImmutableSet;
import io.grpc.NameResolver;
+import io.grpc.Uri;
import io.grpc.NameResolver.Args;
import io.grpc.NameResolverProvider;
import io.grpc.binder.AndroidComponentAddress;
@@ -46,7 +47,17 @@ public String getDefaultScheme() {
@Override
public NameResolver newNameResolver(URI targetUri, final Args args) {
if (Objects.equals(targetUri.getScheme(), ANDROID_INTENT_SCHEME)) {
- return new IntentNameResolver(parseUriArg(targetUri), args);
+ return new IntentNameResolver(parseUriArg(targetUri.toString()), args);
+ } else {
+ return null;
+ }
+ }
+
+ @Nullable
+ @Override
+ public NameResolver newNameResolver(Uri targetUri, final Args args) {
+ if (Objects.equals(targetUri.getScheme(), ANDROID_INTENT_SCHEME)) {
+ return new IntentNameResolver(parseUriArg(targetUri.toString()), args);
} else {
return null;
}
@@ -67,9 +78,9 @@ public ImmutableSet> getProducedSocketAddressType
return ImmutableSet.of(AndroidComponentAddress.class);
}
- private static Intent parseUriArg(URI targetUri) {
+ private static Intent parseUriArg(String targetUri) {
try {
- return Intent.parseUri(targetUri.toString(), URI_INTENT_SCHEME);
+ return Intent.parseUri(targetUri, URI_INTENT_SCHEME);
} catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
diff --git a/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java b/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java
index 3351736108e..4b6bf7d06fb 100644
--- a/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java
+++ b/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java
@@ -102,6 +102,9 @@ public String methodName() {
private State reportedState; // Only used on the main thread.
+ @GuardedBy("this")
+ private ComponentName connectedServiceName;
+
@AnyThread
ServiceBinding(
Executor mainThreadExecutor,
@@ -305,6 +308,26 @@ private void clearReferences() {
sourceContext = null;
}
+ @AnyThread
+ @Override
+ public ServiceInfo getConnectedServiceInfo() throws StatusException {
+ try {
+ return getContextForTargetUser("cross-user v2 handshake")
+ .getPackageManager()
+ .getServiceInfo(getConnectedServiceName(), /* flags= */ 0);
+ } catch (PackageManager.NameNotFoundException e) {
+ throw Status.UNIMPLEMENTED
+ .withCause(e)
+ .withDescription("connected remote service was uninstalled/disabled during handshake")
+ .asException();
+ }
+ }
+
+ private synchronized ComponentName getConnectedServiceName() {
+ checkState(connectedServiceName != null, "onBound() not yet called!");
+ return connectedServiceName;
+ }
+
@Override
@MainThread
public void onServiceConnected(ComponentName className, IBinder binder) {
@@ -312,6 +335,7 @@ public void onServiceConnected(ComponentName className, IBinder binder) {
synchronized (this) {
if (state == State.BINDING) {
state = State.BOUND;
+ connectedServiceName = className;
bound = true;
}
}
diff --git a/binder/src/main/java/io/grpc/binder/internal/SimplePromise.java b/binder/src/main/java/io/grpc/binder/internal/SimplePromise.java
new file mode 100644
index 00000000000..c7d227fbf64
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/SimplePromise.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2025 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.binder.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Placeholder for an object that will be provided later.
+ *
+ * Similar to {@link com.google.common.util.concurrent.SettableFuture}, except it cannot fail or
+ * be cancelled. Most importantly, this class guarantees that {@link Listener}s run one-at-a-time
+ * and in the same order that they were scheduled. This conveniently matches the expectations of
+ * most listener interfaces in the io.grpc universe.
+ *
+ *
Not safe for concurrent use by multiple threads. Thread-compatible for callers that provide
+ * synchronization externally.
+ */
+public class SimplePromise {
+ private T value;
+ private List> pendingListeners; // Allocated lazily in the hopes it's never needed.
+
+ /**
+ * Provides the promised object and runs any pending listeners.
+ *
+ * @throws IllegalStateException if this method has already been called
+ * @throws RuntimeException if some pending listener threw when we tried to run it
+ */
+ public void set(T value) {
+ checkNotNull(value, "value");
+ checkState(this.value == null, "Already set!");
+ this.value = value;
+ if (pendingListeners != null) {
+ for (Listener listener : pendingListeners) {
+ listener.notify(value);
+ }
+ pendingListeners = null;
+ }
+ }
+
+ /**
+ * Returns the promised object, under the assumption that it's already been set.
+ *
+ * Compared to {@link #runWhenSet(Listener)}, this method may be a more efficient way to access
+ * the promised value in the case where you somehow know externally that {@link #set(T)} has
+ * "happened-before" this call.
+ *
+ * @throws IllegalStateException if {@link #set(T)} has not yet been called
+ */
+ public T get() {
+ checkState(value != null, "Not yet set!");
+ return value;
+ }
+
+ /**
+ * Runs the given listener when this promise is fulfilled, or immediately if already fulfilled.
+ *
+ * @throws RuntimeException if already fulfilled and 'listener' threw when we tried to run it
+ */
+ public void runWhenSet(Listener listener) {
+ if (value != null) {
+ listener.notify(value);
+ } else {
+ if (pendingListeners == null) {
+ pendingListeners = new ArrayList<>();
+ }
+ pendingListeners.add(listener);
+ }
+ }
+
+ /**
+ * An object that wants to get notified when a SimplePromise has been fulfilled.
+ */
+ public interface Listener {
+ /**
+ * Indicates that the associated SimplePromise has been fulfilled with the given `value`.
+ */
+ void notify(T value);
+ }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java b/binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java
index e7e73e6d4b0..d261ce43c8c 100644
--- a/binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java
+++ b/binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java
@@ -20,17 +20,21 @@
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.doThrow;
import static org.robolectric.Shadows.shadowOf;
import android.os.IBinder;
import android.os.Looper;
import android.os.Parcel;
+import android.os.RemoteException;
import com.google.common.collect.ImmutableList;
import io.grpc.Attributes;
+import io.grpc.ServerStreamTracer;
import io.grpc.Status;
import io.grpc.internal.FixedObjectPool;
import io.grpc.internal.MockServerTransportListener;
+import io.grpc.internal.ObjectPool;
+import java.util.List;
import java.util.concurrent.ScheduledExecutorService;
import org.junit.Before;
import org.junit.Rule;
@@ -60,26 +64,106 @@ public final class BinderServerTransportTest {
@Before
public void setUp() throws Exception {
- transport =
- new BinderServerTransport(
- new FixedObjectPool<>(executorService),
- Attributes.EMPTY,
- ImmutableList.of(),
- OneWayBinderProxy.IDENTITY_DECORATOR,
- mockBinder);
transportListener = new MockServerTransportListener(transport);
}
+ // Provide defaults so that we can "include only relevant details in tests."
+ BinderServerTransportBuilder newBinderServerTransportBuilder() {
+ return new BinderServerTransportBuilder()
+ .setExecutorServicePool(new FixedObjectPool<>(executorService))
+ .setAttributes(Attributes.EMPTY)
+ .setStreamTracerFactories(ImmutableList.of())
+ .setBinderDecorator(OneWayBinderProxy.IDENTITY_DECORATOR)
+ .setCallbackBinder(mockBinder);
+ }
+
@Test
- public void testSetupTransactionFailureCausesMultipleShutdowns_b153460678() throws Exception {
+ public void testSetupTransactionFailureReportsMultipleTerminations_b153460678() throws Exception {
// Make the binder fail the setup transaction.
- when(mockBinder.transact(anyInt(), any(Parcel.class), isNull(), anyInt())).thenReturn(false);
- transport.setServerTransportListener(transportListener);
+ doThrow(new RemoteException())
+ .when(mockBinder)
+ .transact(anyInt(), any(Parcel.class), isNull(), anyInt());
+ transport = newBinderServerTransportBuilder().setCallbackBinder(mockBinder).build();
+ shadowOf(Looper.getMainLooper()).idle();
+ transport.start(transportListener);
+
+ // Now shut it down externally *before* executing Runnables scheduled on the executor.
+ transport.shutdownNow(Status.UNKNOWN.withDescription("reasons"));
+ shadowOf(Looper.getMainLooper()).idle();
+
+ assertThat(transportListener.isTerminated()).isTrue();
+ }
+
+ @Test
+ public void testClientBinderIsDeadOnArrival() throws Exception {
+ transport = newBinderServerTransportBuilder()
+ .setCallbackBinder(new FakeDeadBinder())
+ .build();
+ transport.start(transportListener);
+ shadowOf(Looper.getMainLooper()).idle();
+
+ assertThat(transportListener.isTerminated()).isTrue();
+ }
+
+ @Test
+ public void testStartAfterShutdownAndIdle() throws Exception {
+ transport = newBinderServerTransportBuilder().build();
+ transport.shutdownNow(Status.UNKNOWN.withDescription("reasons"));
+ shadowOf(Looper.getMainLooper()).idle();
+ transport.start(transportListener);
+ shadowOf(Looper.getMainLooper()).idle();
- // Now shut it down.
+ assertThat(transportListener.isTerminated()).isTrue();
+ }
+
+ @Test
+ public void testStartAfterShutdownNoIdle() throws Exception {
+ transport = newBinderServerTransportBuilder().build();
transport.shutdownNow(Status.UNKNOWN.withDescription("reasons"));
+ transport.start(transportListener);
shadowOf(Looper.getMainLooper()).idle();
assertThat(transportListener.isTerminated()).isTrue();
}
+
+ static class BinderServerTransportBuilder {
+ ObjectPool executorServicePool;
+ Attributes attributes;
+ List streamTracerFactories;
+ OneWayBinderProxy.Decorator binderDecorator;
+ IBinder callbackBinder;
+
+ public BinderServerTransport build() {
+ return BinderServerTransport.create(
+ executorServicePool, attributes, streamTracerFactories, binderDecorator, callbackBinder);
+ }
+
+ public BinderServerTransportBuilder setExecutorServicePool(
+ ObjectPool executorServicePool) {
+ this.executorServicePool = executorServicePool;
+ return this;
+ }
+
+ public BinderServerTransportBuilder setAttributes(Attributes attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public BinderServerTransportBuilder setStreamTracerFactories(
+ List streamTracerFactories) {
+ this.streamTracerFactories = streamTracerFactories;
+ return this;
+ }
+
+ public BinderServerTransportBuilder setBinderDecorator(
+ OneWayBinderProxy.Decorator binderDecorator) {
+ this.binderDecorator = binderDecorator;
+ return this;
+ }
+
+ public BinderServerTransportBuilder setCallbackBinder(IBinder callbackBinder) {
+ this.callbackBinder = callbackBinder;
+ return this;
+ }
+ }
}
diff --git a/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverProviderTest.java b/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverProviderTest.java
index aa75ba84b09..2809a72fee1 100644
--- a/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverProviderTest.java
+++ b/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverProviderTest.java
@@ -30,6 +30,7 @@
import io.grpc.NameResolver.ServiceConfigParser;
import io.grpc.NameResolverProvider;
import io.grpc.SynchronizationContext;
+import io.grpc.Uri;
import io.grpc.binder.ApiConstants;
import java.net.URI;
import org.junit.Before;
@@ -70,18 +71,32 @@ public void testProviderScheme_returnsIntentScheme() throws Exception {
@Test
public void testNoResolverForUnknownScheme_returnsNull() throws Exception {
- assertThat(provider.newNameResolver(new URI("random://uri"), args)).isNull();
+ assertThat(provider.newNameResolver(Uri.create("random://uri"), args)).isNull();
}
@Test
public void testResolutionWithBadUri_throwsIllegalArg() throws Exception {
assertThrows(
IllegalArgumentException.class,
- () -> provider.newNameResolver(new URI("intent:xxx#Intent;e.x=1;end;"), args));
+ () -> provider.newNameResolver(Uri.create("intent:xxx#Intent;e.x=1;end;"), args));
}
@Test
public void testResolverForIntentScheme_returnsResolver() throws Exception {
+ Uri uri = Uri.create("intent:#Intent;action=action;end");
+ NameResolver resolver = provider.newNameResolver(uri, args);
+ assertThat(resolver).isNotNull();
+ assertThat(resolver.getServiceAuthority()).isEqualTo("localhost");
+ syncContext.execute(() -> resolver.start(mockListener));
+ shadowOf(getMainLooper()).idle();
+ verify(mockListener).onResult2(resultCaptor.capture());
+ assertThat(resultCaptor.getValue().getAddressesOrError()).isNotNull();
+ syncContext.execute(resolver::shutdown);
+ shadowOf(getMainLooper()).idle();
+ }
+
+ @Test
+ public void testResolverForIntentScheme_returnsResolver_javaNetUri() throws Exception {
URI uri = new URI("intent://authority/path#Intent;action=action;scheme=scheme;end");
NameResolver resolver = provider.newNameResolver(uri, args);
assertThat(resolver).isNotNull();
diff --git a/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java b/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java
index d3d73f0e9eb..63c47bf4f19 100644
--- a/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java
+++ b/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java
@@ -18,13 +18,17 @@
import static android.os.IBinder.FLAG_ONEWAY;
import static android.os.Process.myUid;
+import static com.google.common.truth.Truth.assertAbout;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static io.grpc.StatusSubject.status;
import static io.grpc.binder.internal.BinderTransport.REMOTE_UID;
import static io.grpc.binder.internal.BinderTransport.SETUP_TRANSPORT;
import static io.grpc.binder.internal.BinderTransport.SHUTDOWN_TRANSPORT;
import static io.grpc.binder.internal.BinderTransport.WIRE_FORMAT_VERSION;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -43,26 +47,35 @@
import androidx.test.core.content.pm.ApplicationInfoBuilder;
import androidx.test.core.content.pm.PackageInfoBuilder;
import com.google.common.collect.ImmutableList;
+import com.google.common.truth.TruthJUnit;
import io.grpc.Attributes;
+import io.grpc.CallOptions;
import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.Metadata;
import io.grpc.ServerStreamTracer;
import io.grpc.Status;
import io.grpc.binder.AndroidComponentAddress;
import io.grpc.binder.ApiConstants;
import io.grpc.binder.AsyncSecurityPolicy;
import io.grpc.binder.SecurityPolicies;
+import io.grpc.binder.internal.OneWayBinderProxies.*;
import io.grpc.binder.internal.SettableAsyncSecurityPolicy.AuthRequest;
import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListenerBase;
import io.grpc.internal.ClientTransport;
import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.DisconnectError;
import io.grpc.internal.GrpcUtil;
import io.grpc.internal.InternalServer;
import io.grpc.internal.ManagedClientTransport;
import io.grpc.internal.MockServerTransportListener;
import io.grpc.internal.ObjectPool;
import io.grpc.internal.SharedResourcePool;
+import java.io.InputStream;
import java.util.List;
+import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import org.junit.Before;
@@ -98,6 +111,9 @@
@LooperMode(Mode.INSTRUMENTATION_TEST)
public final class RobolectricBinderTransportTest extends AbstractTransportTest {
+ static final int SERVER_APP_UID = 11111;
+ static final int EPHEMERAL_SERVER_UID = 22222; // UID of isolated server process.
+
private final Application application = ApplicationProvider.getApplicationContext();
private final ObjectPool executorServicePool =
SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
@@ -110,20 +126,29 @@ public final class RobolectricBinderTransportTest extends AbstractTransportTest
@Mock AsyncSecurityPolicy mockClientSecurityPolicy;
- @Captor
- ArgumentCaptor statusCaptor;
+ @Captor ArgumentCaptor statusCaptor;
ApplicationInfo serverAppInfo;
PackageInfo serverPkgInfo;
ServiceInfo serviceInfo;
private int nextServerAddress;
-
- @Parameter public boolean preAuthServersParam;
-
- @Parameters(name = "preAuthServersParam={0}")
- public static ImmutableList data() {
- return ImmutableList.of(true, false);
+ private BlockingBinderDecorator blockingDecorator =
+ new BlockingBinderDecorator<>();
+
+ @Parameter(value = 0)
+ public boolean preAuthServersParam;
+
+ @Parameter(value = 1)
+ public boolean useLegacyAuthStrategy;
+
+ @Parameters(name = "preAuthServersParam={0};useLegacyAuthStrategy={1}")
+ public static ImmutableList data() {
+ return ImmutableList.of(
+ new Object[] {false, false},
+ new Object[] {false, true},
+ new Object[] {true, false},
+ new Object[] {true, true});
}
@Override
@@ -153,27 +178,34 @@ public void requestRealisticBindServiceBehavior() {
shadowOf(application).setUnbindServiceCallsOnServiceDisconnected(false);
}
- @Override
- protected InternalServer newServer(List streamTracerFactories) {
+ BinderServer.Builder newServerBuilder() {
AndroidComponentAddress listenAddr =
AndroidComponentAddress.forBindIntent(
new Intent()
.setClassName(serviceInfo.packageName, serviceInfo.name)
.setAction("io.grpc.action.BIND." + nextServerAddress++));
- BinderServer binderServer =
- new BinderServer.Builder()
- .setListenAddress(listenAddr)
- .setExecutorPool(serverExecutorPool)
- .setExecutorServicePool(executorServicePool)
- .setStreamTracerFactories(streamTracerFactories)
- .build();
+ return new BinderServer.Builder()
+ .setListenAddress(listenAddr)
+ .setExecutorPool(serverExecutorPool)
+ .setExecutorServicePool(executorServicePool)
+ .setStreamTracerFactories(List.of());
+ }
+ void registerServerWithRobolectric(BinderServer server) {
+ AndroidComponentAddress listenAddr = (AndroidComponentAddress) server.getListenSocketAddress();
shadowOf(application.getPackageManager()).addServiceIfNotPresent(listenAddr.getComponent());
shadowOf(application)
.setComponentNameAndServiceForBindServiceForIntent(
- listenAddr.asBindIntent(), listenAddr.getComponent(), binderServer.getHostBinder());
- return binderServer;
+ listenAddr.asBindIntent(), listenAddr.getComponent(), server.getHostBinder());
+ }
+
+ @Override
+ protected InternalServer newServer(List streamTracerFactories) {
+ BinderServer server =
+ newServerBuilder().setStreamTracerFactories(streamTracerFactories).build();
+ registerServerWithRobolectric(server);
+ return server;
}
@Override
@@ -189,6 +221,7 @@ protected InternalServer newServer(
BinderClientTransportFactory.Builder newClientTransportFactoryBuilder() {
return new BinderClientTransportFactory.Builder()
.setPreAuthorizeServers(preAuthServersParam)
+ .setUseLegacyAuthStrategy(useLegacyAuthStrategy)
.setSourceContext(application)
.setScheduledExecutorPool(executorServicePool)
.setOffloadExecutorPool(offloadExecutorPool);
@@ -223,9 +256,9 @@ public void clientAuthorizesServerUidsInOrder() throws Exception {
// lets us fake value this *globally*. So the ShadowBinder#setCallingUid() here unrealistically
// affects the server's view of the client's uid too. For now this doesn't matter because this
// test never exercises server SecurityPolicy.
- ShadowBinder.setCallingUid(11111); // UID of the server *process*.
+ ShadowBinder.setCallingUid(EPHEMERAL_SERVER_UID);
- serverPkgInfo.applicationInfo.uid = 22222; // UID of the server *app*, which can be different.
+ serverPkgInfo.applicationInfo.uid = SERVER_APP_UID;
shadowOf(application.getPackageManager()).installPackage(serverPkgInfo);
shadowOf(application.getPackageManager()).addOrUpdateService(serviceInfo);
server = newServer(ImmutableList.of());
@@ -243,13 +276,17 @@ public void clientAuthorizesServerUidsInOrder() throws Exception {
if (preAuthServersParam) {
AuthRequest preAuthRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_MS, MILLISECONDS);
- assertThat(preAuthRequest.uid).isEqualTo(22222);
+ assertThat(preAuthRequest.uid).isEqualTo(SERVER_APP_UID);
verify(mockClientTransportListener, never()).transportReady();
preAuthRequest.setResult(Status.OK);
}
AuthRequest authRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_MS, MILLISECONDS);
- assertThat(authRequest.uid).isEqualTo(11111);
+ if (useLegacyAuthStrategy) {
+ assertThat(authRequest.uid).isEqualTo(EPHEMERAL_SERVER_UID);
+ } else {
+ assertThat(authRequest.uid).isEqualTo(SERVER_APP_UID);
+ }
verify(mockClientTransportListener, never()).transportReady();
authRequest.setResult(Status.OK);
@@ -320,6 +357,10 @@ public void clientIgnoresDuplicateSetupTransaction() throws Exception {
@Test
public void clientIgnoresTransactionFromNonServerUids() throws Exception {
server.start(serverListener);
+
+ // This test is not applicable to the new auth strategy which keeps the client Binder a secret.
+ assumeTrue(useLegacyAuthStrategy);
+
client = newClientTransport(server);
startTransport(client, mockClientTransportListener);
@@ -336,7 +377,7 @@ public void clientIgnoresTransactionFromNonServerUids() throws Exception {
sendShutdownTransportTransactionAsUid(client, serverUid);
verify(mockClientTransportListener, timeout(TIMEOUT_MS))
- .transportShutdown(statusCaptor.capture());
+ .transportShutdown(statusCaptor.capture(), any(DisconnectError.class));
assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
assertThat(statusCaptor.getValue().getDescription()).contains("shutdown");
}
@@ -353,6 +394,32 @@ static void sendShutdownTransportTransactionAsUid(ClientTransport client, int se
}
}
+ @Test
+ public void clientReportsAuthzErrorToServer() throws Exception {
+ server.start(serverListener);
+ client =
+ newClientTransportBuilder()
+ .setFactory(
+ newClientTransportFactoryBuilder()
+ .setSecurityPolicy(SecurityPolicies.permissionDenied("test"))
+ .buildClientTransportFactory())
+ .build();
+ runIfNotNull(client.start(mockClientTransportListener));
+ verify(mockClientTransportListener, timeout(TIMEOUT_MS))
+ .transportShutdown(statusCaptor.capture(), any(DisconnectError.class));
+ assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.PERMISSION_DENIED);
+
+ // Client doesn't tell the server in this case by design -- we don't even want to start it!
+ TruthJUnit.assume().that(preAuthServersParam).isFalse();
+ // Similar story here. The client won't send a setup transaction to an unauthorized server.
+ TruthJUnit.assume().that(useLegacyAuthStrategy).isTrue();
+
+ MockServerTransportListener serverTransportListener =
+ serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+ serverTransportListener.waitForTermination(TIMEOUT_MS, MILLISECONDS);
+ assertThat(serverTransportListener.isTerminated()).isTrue();
+ }
+
@Test
@Override
// We don't quite pass the official/abstract version of this test yet because
@@ -384,4 +451,248 @@ public void flowControlPushBack() {}
@Ignore("See BinderTransportTest#serverAlreadyListening")
@Override
public void serverAlreadyListening() {}
+
+ @Test
+ public void singleTxnMsgsDeliveredToServerOutOfOrder() throws Exception {
+ server.start(serverListener);
+ client =
+ newClientTransportBuilder()
+ .setFactory(
+ newClientTransportFactoryBuilder()
+ .setBinderDecorator(blockingDecorator)
+ .buildClientTransportFactory())
+ .build();
+ runIfNotNull(client.start(mockClientTransportListener));
+ blockingDecorator.putNextResult(takeNextBinder(blockingDecorator)); // Endpoint binder.
+ QueueingOneWayBinderProxy queueingServerProxy =
+ new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator)); // Server binder.
+ blockingDecorator.putNextResult(queueingServerProxy);
+
+ verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+ ClientStream stream =
+ client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+ ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+ stream.start(clientStreamListener);
+ stream.writeMessage(methodDescriptor.streamRequest("one"));
+ stream.writeMessage(methodDescriptor.streamRequest("two"));
+ stream.halfClose();
+
+ // Expect one transaction for headers, one for each message, and one for half-close.
+ QueueingOneWayBinderProxy.Transaction txHeaders = takeNextTransaction(queueingServerProxy);
+ QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingServerProxy);
+ QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingServerProxy);
+ QueueingOneWayBinderProxy.Transaction txHalfClose = takeNextTransaction(queueingServerProxy);
+
+ // Deliver messages out of order!
+ queueingServerProxy.deliver(txHeaders);
+ queueingServerProxy.deliver(tx2);
+ queueingServerProxy.deliver(tx1);
+ queueingServerProxy.deliver(txHalfClose);
+
+ MockServerTransportListener serverTransportListener =
+ serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+ MockServerTransportListener.StreamCreation serverStreamCreation =
+ serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+ serverStreamCreation.stream.request(2);
+
+ // Expect the server to deliver the messages in the order they were originally sent.
+ InputStream msg1 = takeNextMessage(serverStreamCreation.listener.messageQueue);
+ assertThat(methodDescriptor.parseResponse(msg1)).isEqualTo("one");
+
+ InputStream msg2 = takeNextMessage(serverStreamCreation.listener.messageQueue);
+ assertThat(methodDescriptor.parseResponse(msg2)).isEqualTo("two");
+
+ assertThat(serverStreamCreation.listener.awaitHalfClosed(TIMEOUT_MS, MILLISECONDS)).isTrue();
+ serverStreamCreation.stream.close(Status.OK, new Metadata());
+
+ assertAbout(status()).that(clientStreamListener.awaitClose(TIMEOUT_MS, MILLISECONDS)).isOk();
+ assertAbout(status())
+ .that(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, MILLISECONDS))
+ .isOk();
+ }
+
+ @Test
+ public void msgFragmentsDeliveredToServerOutOfOrder() throws Exception {
+ server.start(serverListener);
+ client =
+ newClientTransportBuilder()
+ .setFactory(
+ newClientTransportFactoryBuilder()
+ .setBinderDecorator(blockingDecorator)
+ .buildClientTransportFactory())
+ .build();
+ runIfNotNull(client.start(mockClientTransportListener));
+ blockingDecorator.putNextResult(takeNextBinder(blockingDecorator)); // Endpoint binder.
+ QueueingOneWayBinderProxy queueingServerProxy =
+ new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator)); // Server binder.
+ blockingDecorator.putNextResult(queueingServerProxy);
+
+ verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+ ClientStream stream =
+ client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+ ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+ stream.start(clientStreamListener);
+
+ String largeMessage = newStringOfLength(BlockPool.BLOCK_SIZE + 1);
+ stream.writeMessage(methodDescriptor.streamRequest(largeMessage));
+ stream.halfClose();
+
+ // Expect the client to split largeMessage into two transactions, plus headers and half-close.
+ QueueingOneWayBinderProxy.Transaction txHeaders = takeNextTransaction(queueingServerProxy);
+ QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingServerProxy);
+ QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingServerProxy);
+ QueueingOneWayBinderProxy.Transaction txHalfClose = takeNextTransaction(queueingServerProxy);
+
+ // Deliver fragments out of order!
+ queueingServerProxy.deliver(txHeaders);
+ queueingServerProxy.deliver(tx2);
+ queueingServerProxy.deliver(tx1);
+ queueingServerProxy.deliver(txHalfClose);
+
+ // Verify that the server reassembles the transactions correctly.
+ MockServerTransportListener serverTransportListener =
+ serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+ MockServerTransportListener.StreamCreation serverStreamCreation =
+ serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+ serverStreamCreation.stream.request(1);
+ InputStream msg = takeNextMessage(serverStreamCreation.listener.messageQueue);
+ assertThat(methodDescriptor.parseResponse(msg)).isEqualTo(largeMessage);
+
+ assertThat(serverStreamCreation.listener.awaitHalfClosed(TIMEOUT_MS, MILLISECONDS)).isTrue();
+ serverStreamCreation.stream.close(Status.OK, new Metadata());
+
+ assertAbout(status()).that(clientStreamListener.awaitClose(TIMEOUT_MS, MILLISECONDS)).isOk();
+ assertAbout(status())
+ .that(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, MILLISECONDS))
+ .isOk();
+ }
+
+ @Test
+ public void singleTxnMsgsDeliveredToClientOutOfOrder() throws Exception {
+ server = newServerBuilder().setClientBinderDecorator(blockingDecorator).build();
+ registerServerWithRobolectric((BinderServer) server);
+ server.start(serverListener);
+
+ client = newClientTransport(server);
+ runIfNotNull(client.start(mockClientTransportListener));
+
+ QueueingOneWayBinderProxy queueingClientProxy =
+ new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator));
+ blockingDecorator.putNextResult(queueingClientProxy);
+
+ // Deliver the setup transaction without interference.
+ queueingClientProxy.deliver(takeNextTransaction(queueingClientProxy));
+ verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+ ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+ ClientStream stream =
+ client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+ stream.start(clientStreamListener);
+ stream.halfClose();
+ stream.request(2);
+
+ MockServerTransportListener serverTransportListener =
+ serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+ MockServerTransportListener.StreamCreation serverStreamCreation =
+ serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+
+ serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("one"));
+ serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("two"));
+ serverStreamCreation.stream.close(Status.OK, new Metadata());
+
+ // Expect one transaction from the server for each message.
+ QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingClientProxy);
+ QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingClientProxy);
+ QueueingOneWayBinderProxy.Transaction txClose = takeNextTransaction(queueingClientProxy);
+
+ // Deliver messages to the client out of order!
+ queueingClientProxy.deliver(tx2);
+ queueingClientProxy.deliver(tx1);
+ queueingClientProxy.deliver(txClose);
+
+ // Client should deliver messages to the application in the order sent.
+ InputStream msg1 = takeNextMessage(clientStreamListener.messageQueue);
+ assertThat(methodDescriptor.parseResponse(msg1)).isEqualTo("one");
+ InputStream msg2 = takeNextMessage(clientStreamListener.messageQueue);
+ assertThat(methodDescriptor.parseResponse(msg2)).isEqualTo("two");
+
+ assertAbout(status()).that(clientStreamListener.awaitClose(TIMEOUT_MS, MILLISECONDS)).isOk();
+ assertAbout(status())
+ .that(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, MILLISECONDS))
+ .isOk();
+ }
+
+ @Test
+ public void msgFragmentsDeliveredToClientOutOfOrder() throws Exception {
+ server = newServerBuilder().setClientBinderDecorator(blockingDecorator).build();
+ registerServerWithRobolectric((BinderServer) server);
+ server.start(serverListener);
+
+ client = newClientTransport(server);
+ runIfNotNull(client.start(mockClientTransportListener));
+
+ QueueingOneWayBinderProxy queueingClientProxy =
+ new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator));
+ blockingDecorator.putNextResult(queueingClientProxy);
+
+ // Deliver the setup transaction without interference.
+ queueingClientProxy.deliver(takeNextTransaction(queueingClientProxy));
+ verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+ ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+ ClientStream stream =
+ client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+ stream.start(clientStreamListener);
+ stream.request(1);
+
+ MockServerTransportListener serverTransportListener =
+ serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+ MockServerTransportListener.StreamCreation serverStreamCreation =
+ serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+
+ String largeMessage = newStringOfLength(BlockPool.BLOCK_SIZE + 1);
+ serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+ serverStreamCreation.stream.flush();
+
+ // Expect the client to split largeMessage into two transactions.
+ QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingClientProxy);
+ QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingClientProxy);
+
+ // Deliver them to the client out of order!
+ queueingClientProxy.deliver(tx2);
+ queueingClientProxy.deliver(tx1);
+
+ // Client should reassemble the message correctly.
+ InputStream msg = takeNextMessage(clientStreamListener.messageQueue);
+ assertThat(methodDescriptor.parseResponse(msg)).isEqualTo(largeMessage);
+ }
+
+ private static OneWayBinderProxy takeNextBinder(
+ BlockingBinderDecorator decorator) throws InterruptedException {
+ OneWayBinderProxy proxy = decorator.takeNextRequest(TIMEOUT_MS, MILLISECONDS);
+ assertThat(proxy).isNotNull();
+ return proxy;
+ }
+
+ private static QueueingOneWayBinderProxy.Transaction takeNextTransaction(
+ QueueingOneWayBinderProxy proxy) throws InterruptedException {
+ QueueingOneWayBinderProxy.Transaction tx = proxy.pollNextTransaction(TIMEOUT_MS, MILLISECONDS);
+ assertThat(tx).isNotNull();
+ return tx;
+ }
+
+ private static InputStream takeNextMessage(BlockingQueue messageQueue)
+ throws InterruptedException {
+ InputStream msg = messageQueue.poll(TIMEOUT_MS, MILLISECONDS);
+ assertThat(msg).isNotNull();
+ return msg;
+ }
+
+ private static String newStringOfLength(int numChars) {
+ char[] chars = new char[numChars];
+ java.util.Arrays.fill(chars, 'x');
+ return new String(chars);
+ }
}
diff --git a/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java b/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java
index 0875881dcc5..0f57b6f8a30 100644
--- a/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java
+++ b/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java
@@ -52,7 +52,6 @@
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
-import org.robolectric.shadows.ShadowDevicePolicyManager;
@RunWith(RobolectricTestRunner.class)
public final class ServiceBindingTest {
@@ -116,6 +115,32 @@ public void testBind() throws Exception {
assertThat(binding.isSourceContextCleared()).isFalse();
}
+ @Test
+ public void testGetConnectedServiceInfo() throws Exception {
+ binding = newBuilder().setTargetComponent(serviceComponent).build();
+ binding.bind();
+ shadowOf(getMainLooper()).idle();
+
+ assertThat(observer.gotBoundEvent).isTrue();
+
+ ServiceInfo serviceInfo = binding.getConnectedServiceInfo();
+ assertThat(serviceInfo.name).isEqualTo(serviceComponent.getClassName());
+ assertThat(serviceInfo.packageName).isEqualTo(serviceComponent.getPackageName());
+ }
+
+ @Test
+ public void testGetConnectedServiceInfoThrows() throws Exception {
+ binding = newBuilder().setTargetComponent(serviceComponent).build();
+ binding.bind();
+ shadowOf(getMainLooper()).idle();
+
+ assertThat(observer.gotBoundEvent).isTrue();
+ shadowOf(appContext.getPackageManager()).removeService(serviceComponent);
+
+ StatusException se = assertThrows(StatusException.class, binding::getConnectedServiceInfo);
+ assertThat(se.getStatus().getCode()).isEqualTo(Code.UNIMPLEMENTED);
+ }
+
@Test
public void testBindingIntent() throws Exception {
shadowApplication.setComponentNameAndServiceForBindService(null, null);
@@ -365,12 +390,12 @@ public void testBindServiceAsUser_returnsErrorWhenSdkBelowR() {
@Test
@Config(sdk = 28)
public void testDevicePolicyBlind_returnsErrorWhenSdkBelowR() {
- String deviceAdminClassName = "DevicePolicyAdmin";
- ComponentName adminComponent = new ComponentName(appContext, deviceAdminClassName);
- allowBindDeviceAdminForUser(appContext, adminComponent, 10);
+ ComponentName adminComponent = new ComponentName(appContext, "DevicePolicyAdmin");
+ UserHandle user10 = generateUserHandle(/* userId= */ 10);
+ allowBindDeviceAdminForUser(appContext, adminComponent, user10);
binding =
newBuilder()
- .setTargetUserHandle(UserHandle.getUserHandleForUid(10))
+ .setTargetUserHandle(user10)
.setChannelCredentials(BinderChannelCredentials.forDevicePolicyAdmin(adminComponent))
.build();
binding.bind();
@@ -384,13 +409,13 @@ public void testDevicePolicyBlind_returnsErrorWhenSdkBelowR() {
@Test
@Config(sdk = 30)
public void testBindWithDeviceAdmin() throws Exception {
- String deviceAdminClassName = "DevicePolicyAdmin";
- ComponentName adminComponent = new ComponentName(appContext, deviceAdminClassName);
- allowBindDeviceAdminForUser(appContext, adminComponent, /* userId= */ 0);
+ ComponentName adminComponent = new ComponentName(appContext, "DevicePolicyAdmin");
+ UserHandle user0 = generateUserHandle(/* userId= */ 0);
+ allowBindDeviceAdminForUser(appContext, adminComponent, user0);
binding =
newBuilder()
- .setTargetUserHandle(UserHandle.getUserHandleForUid(/* uid= */ 0))
- .setTargetUserHandle(generateUserHandle(/* userId= */ 0))
+ .setTargetUserHandle(user0)
+ .setTargetComponent(serviceComponent)
.setChannelCredentials(BinderChannelCredentials.forDevicePolicyAdmin(adminComponent))
.build();
shadowOf(getMainLooper()).idle();
@@ -403,6 +428,10 @@ public void testBindWithDeviceAdmin() throws Exception {
assertThat(observer.binder).isSameInstanceAs(mockBinder);
assertThat(observer.gotUnboundEvent).isFalse();
assertThat(binding.isSourceContextCleared()).isFalse();
+
+ ServiceInfo serviceInfo = binding.getConnectedServiceInfo();
+ assertThat(serviceInfo.name).isEqualTo(serviceComponent.getClassName());
+ assertThat(serviceInfo.packageName).isEqualTo(serviceComponent.getPackageName());
}
private void assertNoLockHeld() {
@@ -418,15 +447,10 @@ private void assertNoLockHeld() {
}
private static void allowBindDeviceAdminForUser(
- Context context, ComponentName admin, int userId) {
- ShadowDevicePolicyManager devicePolicyManager =
- shadowOf(context.getSystemService(DevicePolicyManager.class));
- devicePolicyManager.setDeviceOwner(admin);
- devicePolicyManager.setBindDeviceAdminTargetUsers(
- Arrays.asList(UserHandle.getUserHandleForUid(userId)));
- shadowOf((DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE));
- devicePolicyManager.setDeviceOwner(admin);
- devicePolicyManager.setBindDeviceAdminTargetUsers(Arrays.asList(generateUserHandle(userId)));
+ Context context, ComponentName admin, UserHandle user) {
+ DevicePolicyManager devicePolicyManager = context.getSystemService(DevicePolicyManager.class);
+ shadowOf(devicePolicyManager).setBindDeviceAdminTargetUsers(Arrays.asList(user));
+ shadowOf(devicePolicyManager).setDeviceOwner(admin);
}
/** Generate UserHandles the hard way. */
diff --git a/binder/src/test/java/io/grpc/binder/internal/SimplePromiseTest.java b/binder/src/test/java/io/grpc/binder/internal/SimplePromiseTest.java
new file mode 100644
index 00000000000..6486ff5e8a1
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/SimplePromiseTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2025 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.binder.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.binder.internal.SimplePromise.Listener;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public final class SimplePromiseTest {
+
+ private static final String FULFILLED_VALUE = "a fulfilled value";
+
+ @Mock private Listener mockListener1;
+ @Mock private Listener mockListener2;
+ @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+ private SimplePromise promise = new SimplePromise<>();
+
+ @Before
+ public void setUp() {
+ }
+
+ @Test
+ public void get_beforeFulfilled_throws() {
+ IllegalStateException e = assertThrows(IllegalStateException.class, () -> promise.get());
+ assertThat(e).hasMessageThat().isEqualTo("Not yet set!");
+ }
+
+ @Test
+ public void get_afterFulfilled_returnsValue() {
+ promise.set(FULFILLED_VALUE);
+ assertThat(promise.get()).isEqualTo(FULFILLED_VALUE);
+ }
+
+ @Test
+ public void set_withNull_throws() {
+ assertThrows(NullPointerException.class, () -> promise.set(null));
+ }
+
+ @Test
+ public void set_calledTwice_throws() {
+ promise.set(FULFILLED_VALUE);
+ IllegalStateException e =
+ assertThrows(IllegalStateException.class, () -> promise.set("another value"));
+ assertThat(e).hasMessageThat().isEqualTo("Already set!");
+ }
+
+ @Test
+ public void runWhenSet_beforeFulfill_listenerIsNotifiedUponSet() {
+ promise.runWhenSet(mockListener1);
+
+ // Should not have been called yet.
+ verify(mockListener1, never()).notify(FULFILLED_VALUE);
+
+ promise.set(FULFILLED_VALUE);
+
+ // Now it should be called.
+ verify(mockListener1, times(1)).notify(FULFILLED_VALUE);
+ }
+
+ @Test
+ public void runWhenSet_afterSet_listenerIsNotifiedImmediately() {
+ promise.set(FULFILLED_VALUE);
+ promise.runWhenSet(mockListener1);
+
+ // Should have been called immediately.
+ verify(mockListener1, times(1)).notify(FULFILLED_VALUE);
+ }
+
+ @Test
+ public void multipleListeners_addedBeforeSet_allNotifiedInOrder() {
+ promise.runWhenSet(mockListener1);
+ promise.runWhenSet(mockListener2);
+
+ promise.set(FULFILLED_VALUE);
+
+ InOrder inOrder = inOrder(mockListener1, mockListener2);
+ inOrder.verify(mockListener1).notify(FULFILLED_VALUE);
+ inOrder.verify(mockListener2).notify(FULFILLED_VALUE);
+ }
+
+ @Test
+ public void listenerThrows_duringSet_propagatesException() {
+ // A listener that will throw when notified.
+ Listener throwingListener =
+ (value) -> {
+ throw new UnsupportedOperationException("Listener failed");
+ };
+
+ promise.runWhenSet(throwingListener);
+
+ // Fulfilling the promise should now throw the exception from the listener.
+ UnsupportedOperationException e =
+ assertThrows(UnsupportedOperationException.class, () -> promise.set(FULFILLED_VALUE));
+ assertThat(e).hasMessageThat().isEqualTo("Listener failed");
+ }
+
+ @Test
+ public void listenerThrows_whenAddedAfterSet_propagatesException() {
+ promise.set(FULFILLED_VALUE);
+
+ // A listener that will throw when notified.
+ Listener throwingListener =
+ (value) -> {
+ throw new UnsupportedOperationException("Listener failed");
+ };
+
+ // Running the listener should throw immediately because the promise is already fulfilled.
+ UnsupportedOperationException e =
+ assertThrows(
+ UnsupportedOperationException.class, () -> promise.runWhenSet(throwingListener));
+ assertThat(e).hasMessageThat().isEqualTo("Listener failed");
+ }
+}
diff --git a/binder/src/testFixtures/java/io/grpc/binder/internal/FakeDeadBinder.java b/binder/src/testFixtures/java/io/grpc/binder/internal/FakeDeadBinder.java
new file mode 100644
index 00000000000..5bce7498c4b
--- /dev/null
+++ b/binder/src/testFixtures/java/io/grpc/binder/internal/FakeDeadBinder.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2025 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.binder.internal;
+
+import android.os.DeadObjectException;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import java.io.FileDescriptor;
+
+/** An {@link IBinder} that behaves as if its hosting process has died, for testing. */
+public class FakeDeadBinder implements IBinder {
+ @Override
+ public boolean isBinderAlive() {
+ return false;
+ }
+
+ @Override
+ public IInterface queryLocalInterface(String descriptor) {
+ return null;
+ }
+
+ @Override
+ public String getInterfaceDescriptor() throws RemoteException {
+ throw new DeadObjectException();
+ }
+
+ @Override
+ public boolean pingBinder() {
+ return false;
+ }
+
+ @Override
+ public void dump(FileDescriptor fd, String[] args) throws RemoteException {
+ throw new DeadObjectException();
+ }
+
+ @Override
+ public void dumpAsync(FileDescriptor fd, String[] args) throws RemoteException {
+ throw new DeadObjectException();
+ }
+
+ @Override
+ public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
+ throw new DeadObjectException();
+ }
+
+ @Override
+ public void linkToDeath(DeathRecipient r, int flags) throws RemoteException {
+ throw new DeadObjectException();
+ }
+
+ @Override
+ public boolean unlinkToDeath(DeathRecipient deathRecipient, int flags) {
+ // No need to check whether 'deathRecipient' was ever actually passed to linkToDeath(): Per our
+ // API contract, if "the IBinder has already died" we never throw and always return false.
+ return false;
+ }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/internal/OneWayBinderProxies.java b/binder/src/testFixtures/java/io/grpc/binder/internal/OneWayBinderProxies.java
similarity index 67%
rename from binder/src/androidTest/java/io/grpc/binder/internal/OneWayBinderProxies.java
rename to binder/src/testFixtures/java/io/grpc/binder/internal/OneWayBinderProxies.java
index 4abdb2c03dd..c7eee06e73a 100644
--- a/binder/src/androidTest/java/io/grpc/binder/internal/OneWayBinderProxies.java
+++ b/binder/src/testFixtures/java/io/grpc/binder/internal/OneWayBinderProxies.java
@@ -18,6 +18,7 @@
import android.os.RemoteException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
import javax.annotation.Nullable;
/** A collection of {@link OneWayBinderProxy}-related test helpers. */
@@ -42,6 +43,18 @@ public OneWayBinderProxy takeNextRequest() throws InterruptedException {
return requests.take();
}
+ /**
+ * Returns the next {@link OneWayBinderProxy} that needs decorating, blocking for up to the
+ * specified timeout if it hasn't yet been provided to {@link #decorate}.
+ *
+ * Follow this with a call to {@link #putNextResult(OneWayBinderProxy)} to provide the result
+ * of {@link #decorate} and unblock the waiting caller.
+ */
+ public OneWayBinderProxy takeNextRequest(long timeout, TimeUnit unit)
+ throws InterruptedException {
+ return requests.poll(timeout, unit);
+ }
+
/** Provides the next value to return from {@link #decorate}. */
public void putNextResult(T next) throws InterruptedException {
results.put(next);
@@ -119,6 +132,49 @@ public void transact(int code, ParcelHolder data) throws RemoteException {
}
}
+ /** A {@link OneWayBinderProxy} that queues transactions for a test to deliver manually later. */
+ public static final class QueueingOneWayBinderProxy extends OneWayBinderProxy {
+ public static final class Transaction {
+ public final int code;
+ private final ParcelHolder parcel;
+
+ public Transaction(int code, ParcelHolder parcel) {
+ this.code = code;
+ this.parcel = parcel;
+ }
+ }
+
+ private final BlockingQueue queue = new LinkedBlockingQueue<>();
+ private final OneWayBinderProxy wrapped;
+
+ public QueueingOneWayBinderProxy(OneWayBinderProxy wrapped) {
+ super(wrapped.getDelegate());
+ this.wrapped = wrapped;
+ }
+
+ @Override
+ public void transact(int code, ParcelHolder data) throws RemoteException {
+ queue.add(new Transaction(code, new ParcelHolder(data.release())));
+ }
+
+ /**
+ * Returns the next transaction that was queued in order, waiting up to the specified timeout.
+ */
+ public Transaction pollNextTransaction(long timeout, TimeUnit unit)
+ throws InterruptedException {
+ return queue.poll(timeout, unit);
+ }
+
+ /**
+ * Delivers a previously queued transaction to its original destination.
+ *
+ * @throws IllegalStateException if transaction was already delivered once before
+ */
+ public void deliver(Transaction transaction) throws RemoteException {
+ wrapped.transact(transaction.code, transaction.parcel);
+ }
+ }
+
// Cannot be instantiated.
private OneWayBinderProxies() {}
;
diff --git a/build.gradle b/build.gradle
index f80b27a4476..077098fd20e 100644
--- a/build.gradle
+++ b/build.gradle
@@ -21,7 +21,7 @@ subprojects {
apply plugin: "net.ltgt.errorprone"
group = "io.grpc"
- version = "1.77.0-SNAPSHOT" // CURRENT_GRPC_VERSION
+ version = "1.83.0-SNAPSHOT" // CURRENT_GRPC_VERSION
repositories {
maven { // The google mirror is less flaky than mavenCentral()
@@ -43,6 +43,7 @@ subprojects {
ignoreGradleMetadataRedirection()
}
}
+ maven { url 'https://central.sonatype.com/repository/maven-snapshots/' }
}
tasks.withType(JavaCompile).configureEach {
@@ -197,6 +198,25 @@ subprojects {
}
}
+ plugins.withId("com.android.base") {
+ android {
+ lint {
+ abortOnError true
+ if (rootProject.hasProperty('failOnWarnings') && rootProject.failOnWarnings.toBoolean()) {
+ warningsAsErrors true
+ }
+ }
+ }
+ tasks.withType(JavaCompile).configureEach {
+ it.options.compilerArgs += [
+ "-Xlint:all"
+ ]
+ if (rootProject.hasProperty('failOnWarnings') && rootProject.failOnWarnings.toBoolean()) {
+ it.options.compilerArgs += ["-Werror"]
+ }
+ }
+ }
+
plugins.withId("java") {
dependencies {
testImplementation libraries.junit,
@@ -514,5 +534,5 @@ configurations {
}
}
-tasks.register('checkForUpdates', CheckForUpdatesTask, project.configurations.checkForUpdates, "libs")
+tasks.register('checkForUpdates', CheckForUpdatesTask, project.configurations.checkForUpdates, "libs", layout.projectDirectory.file("gradle/libs.versions.toml"))
diff --git a/buildSrc/src/main/java/io/grpc/gradle/CheckForUpdatesTask.java b/buildSrc/src/main/java/io/grpc/gradle/CheckForUpdatesTask.java
index 9d0156a1b72..b7c28dbbb2d 100644
--- a/buildSrc/src/main/java/io/grpc/gradle/CheckForUpdatesTask.java
+++ b/buildSrc/src/main/java/io/grpc/gradle/CheckForUpdatesTask.java
@@ -16,11 +16,15 @@
package io.grpc.gradle;
+import java.io.IOException;
+import java.nio.file.Files;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
+import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.inject.Inject;
import org.gradle.api.DefaultTask;
import org.gradle.api.artifacts.Configuration;
@@ -32,6 +36,7 @@
import org.gradle.api.artifacts.result.ResolvedComponentResult;
import org.gradle.api.artifacts.result.ResolvedDependencyResult;
import org.gradle.api.artifacts.result.UnresolvedDependencyResult;
+import org.gradle.api.file.RegularFile;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.Nested;
@@ -45,7 +50,23 @@ public abstract class CheckForUpdatesTask extends DefaultTask {
private final Set libraries;
@Inject
- public CheckForUpdatesTask(Configuration updateConf, String catalog) {
+ public CheckForUpdatesTask(Configuration updateConf, String catalog, RegularFile commentFile)
+ throws IOException {
+ // Check for overrides to the default version selection ('+'), using comments of the form:
+ // # checkForUpdates: library-name:1.2.+
+ List fileComments = Files.lines(commentFile.getAsFile().toPath())
+ .filter(l -> l.matches("# *checkForUpdates:.*"))
+ .map(l -> l.replaceFirst("# *checkForUpdates:", "").trim())
+ .collect(Collectors.toList());
+ Map aliasToVersionSelector = new HashMap<>(2*fileComments.size());
+ for (String comment : fileComments) {
+ String[] parts = comment.split(":", 2);
+ String name = parts[0].replaceAll("[_-]", ".");
+ if (aliasToVersionSelector.put(name, parts[1]) != null) {
+ throw new RuntimeException("Duplicate checkForUpdates comment for library: " + name);
+ }
+ }
+
updateConf.setVisible(false);
updateConf.setTransitive(false);
VersionCatalog versionCatalog = getProject().getExtensions().getByType(VersionCatalogsExtension.class).named(catalog);
@@ -59,8 +80,12 @@ public CheckForUpdatesTask(Configuration updateConf, String catalog) {
oldConf.getDependencies().add(oldDep);
Configuration newConf = updateConf.copy();
+ String versionSelector = aliasToVersionSelector.remove(name);
+ if (versionSelector == null) {
+ versionSelector = "+";
+ }
Dependency newDep = getProject().getDependencies().create(
- depMap(dep.getGroup(), dep.getName(), "+", "pom"));
+ depMap(dep.getGroup(), dep.getName(), versionSelector, "pom"));
newConf.getDependencies().add(newDep);
libraries.add(new Library(
@@ -68,6 +93,10 @@ public CheckForUpdatesTask(Configuration updateConf, String catalog) {
oldConf.getIncoming().getResolutionResult().getRootComponent(),
newConf.getIncoming().getResolutionResult().getRootComponent()));
}
+ if (!aliasToVersionSelector.isEmpty()) {
+ throw new RuntimeException(
+ "Unused checkForUpdates comments: " + aliasToVersionSelector.keySet());
+ }
this.libraries = Collections.unmodifiableSet(libraries);
}
@@ -96,10 +125,16 @@ public void checkForUpdates() {
"- Current version of libs.%s not resolved", name));
continue;
}
+ DependencyResult newResult = lib.getNewResult().get().getDependencies().iterator().next();
+ if (newResult instanceof UnresolvedDependencyResult) {
+ System.out.println(String.format(
+ "- New version of libs.%s not resolved", name));
+ continue;
+ }
ModuleVersionIdentifier oldId =
((ResolvedDependencyResult) oldResult).getSelected().getModuleVersion();
- ModuleVersionIdentifier newId = ((ResolvedDependencyResult) lib.getNewResult().get()
- .getDependencies().iterator().next()).getSelected().getModuleVersion();
+ ModuleVersionIdentifier newId =
+ ((ResolvedDependencyResult) newResult).getSelected().getModuleVersion();
if (oldId != newId) {
System.out.println(String.format(
"libs.%s = %s %s -> %s",
diff --git a/buildscripts/build_docker.sh b/buildscripts/build_docker.sh
index b34f9a6e542..fa75c07c1eb 100755
--- a/buildscripts/build_docker.sh
+++ b/buildscripts/build_docker.sh
@@ -4,5 +4,4 @@ set -eu -o pipefail
readonly buildscripts_dir="$(dirname "$(readlink -f "$0")")"
docker build -t grpc-java-artifacts-x86 "$buildscripts_dir"/grpc-java-artifacts
docker build -t grpc-java-artifacts-multiarch -f "$buildscripts_dir"/grpc-java-artifacts/Dockerfile.multiarch.base "$buildscripts_dir"/grpc-java-artifacts
-docker build -t grpc-java-artifacts-ubuntu2004 -f "$buildscripts_dir"/grpc-java-artifacts/Dockerfile.ubuntu2004.base "$buildscripts_dir"/grpc-java-artifacts
diff --git a/buildscripts/cloudbuild-testing.yaml b/buildscripts/cloudbuild-testing.yaml
new file mode 100644
index 00000000000..623b85b6882
--- /dev/null
+++ b/buildscripts/cloudbuild-testing.yaml
@@ -0,0 +1,64 @@
+substitutions:
+ _GAE_SERVICE_ACCOUNT: appengine-testing-java@grpc-testing.iam.gserviceaccount.com
+options:
+ env:
+ - BUILD_ID=$BUILD_ID
+ - KOKORO_GAE_SERVICE=java-gae-interop-test
+ - DUMMY_DEFAULT_VERSION=dummy-default
+ - GRADLE_OPTS=-Dorg.gradle.jvmargs='-Xmx1g'
+ - GRADLE_FLAGS=-PskipCodegen=true -PskipAndroid=true
+ logging: CLOUD_LOGGING_ONLY
+ machineType: E2_HIGHCPU_8
+
+steps:
+- id: clean-stale-deploys
+ name: gcr.io/cloud-builders/gcloud
+ allowFailure: true
+ script: |
+ #!/usr/bin/env bash
+ set -e
+ echo "Cleaning out stale deploys from previous runs, it is ok if this part fails"
+ # If the test fails, the deployment is leaked.
+ # Delete all versions whose name is not 'dummy-default' and is older than 1 hour.
+ # This expression is an ISO8601 relative date:
+ # https://cloud.google.com/sdk/gcloud/reference/topic/datetimes
+ (gcloud app versions list --format="get(version.id)" \
+ --filter="service=$KOKORO_GAE_SERVICE AND NOT version : '$DUMMY_DEFAULT_VERSION' AND version.createTime<'-p1h'" \
+ | xargs -i gcloud app services delete "$KOKORO_GAE_SERVICE" --version {} --quiet) || true
+
+- name: gcr.io/cloud-builders/docker
+ args: ['build', '-t', 'gae-build', 'buildscripts/gae-build/']
+
+- id: build
+ name: gae-build
+ script: |
+ #!/usr/bin/env bash
+ exec ./gradlew $GRADLE_FLAGS :grpc-gae-interop-testing-jdk8:appengineStage
+
+- id: deploy
+ name: gcr.io/cloud-builders/gcloud
+ args:
+ - app
+ - deploy
+ - gae-interop-testing/gae-jdk8/build/staged-app/app.yaml
+ - --service-account=$_GAE_SERVICE_ACCOUNT
+ - --no-promote
+ - --no-stop-previous-version
+ - --version=cb-$BUILD_ID
+
+- id: runInteropTestRemote
+ name: eclipse-temurin:17-jdk
+ env:
+ - PROJECT_ID=$PROJECT_ID
+ script: |
+ #!/usr/bin/env bash
+ exec ./gradlew $GRADLE_FLAGS --stacktrace -PgaeDeployVersion="cb-$BUILD_ID" \
+ -PgaeProjectId="$PROJECT_ID" :grpc-gae-interop-testing-jdk8:runInteropTestRemote
+
+- id: cleanup
+ name: gcr.io/cloud-builders/gcloud
+ script: |
+ #!/usr/bin/env bash
+ set -e
+ echo "Performing cleanup now."
+ gcloud app services delete "$KOKORO_GAE_SERVICE" --version "cb-$BUILD_ID" --quiet
diff --git a/buildscripts/gae-build/Dockerfile b/buildscripts/gae-build/Dockerfile
new file mode 100644
index 00000000000..7e68b270801
--- /dev/null
+++ b/buildscripts/gae-build/Dockerfile
@@ -0,0 +1,10 @@
+FROM eclipse-temurin:17-jdk
+
+# The AppEngine Gradle plugin downloads and runs its own gcloud to get the .jar
+# to link against, so we need Python even if we use gcloud deploy directly
+# instead of using the plugin.
+RUN export DEBIAN_FRONTEND=noninteractive && \
+ apt-get update && \
+ apt-get upgrade -y && \
+ apt-get install -y --no-install-recommends python3 && \
+ rm -rf /var/lib/apt/lists/*
diff --git a/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base b/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base
index da2c46904ca..b2f5625afe3 100644
--- a/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base
+++ b/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base
@@ -1,4 +1,4 @@
-FROM ubuntu:18.04
+FROM ubuntu:20.04
RUN export DEBIAN_FRONTEND=noninteractive && \
apt-get update && \
@@ -9,7 +9,8 @@ RUN export DEBIAN_FRONTEND=noninteractive && \
curl \
g++-aarch64-linux-gnu \
g++-powerpc64le-linux-gnu \
- openjdk-8-jdk \
+ g++-s390x-linux-gnu \
+ openjdk-11-jdk \
pkg-config \
&& \
rm -rf /var/lib/apt/lists/*
diff --git a/buildscripts/grpc-java-artifacts/Dockerfile.ubuntu2004.base b/buildscripts/grpc-java-artifacts/Dockerfile.ubuntu2004.base
deleted file mode 100644
index e987fb3e684..00000000000
--- a/buildscripts/grpc-java-artifacts/Dockerfile.ubuntu2004.base
+++ /dev/null
@@ -1,19 +0,0 @@
-FROM ubuntu:20.04
-
-RUN export DEBIAN_FRONTEND=noninteractive && \
- apt-get update && \
- apt-get upgrade -y && \
- apt-get install -y --no-install-recommends \
- build-essential \
- ca-certificates \
- curl \
- g++-s390x-linux-gnu \
- openjdk-8-jdk \
- pkg-config \
- && \
- rm -rf /var/lib/apt/lists/*
-
-RUN curl -Ls https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3-linux-x86_64.tar.gz | \
- tar xz -C /var/local
-ENV PATH /var/local/cmake-3.26.3-linux-x86_64/bin:$PATH
-
diff --git a/buildscripts/kokoro/android.sh b/buildscripts/kokoro/android.sh
index 5af55b2f551..f9dc3842f7c 100755
--- a/buildscripts/kokoro/android.sh
+++ b/buildscripts/kokoro/android.sh
@@ -19,7 +19,9 @@ cat <> gradle.properties
org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=1024m
EOF
-export ANDROID_HOME=/tmp/Android/Sdk
+# https://bazel.build/versions/9.1.0/docs/sandboxing gives each worker its own
+# isolated and ephemeral /tmp. Install the Android SDK anywhere but there.
+export ANDROID_HOME=$HOME/Android/Sdk
mkdir -p "${ANDROID_HOME}/cmdline-tools"
curl -Ls -o cmdline.zip \
"https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip"
@@ -27,6 +29,27 @@ unzip -qd "${ANDROID_HOME}/cmdline-tools" cmdline.zip
rm cmdline.zip
mv "${ANDROID_HOME}/cmdline-tools/cmdline-tools" "${ANDROID_HOME}/cmdline-tools/latest"
(yes || true) | "${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager" --licenses
+
+# Bazel/android_rules requires build-tools at least version 35.0.0 and, unlike
+# gradle, won't download anything for itself.
+# TODO(jdcormie): Keep this version in sync with AGP's default and any
+# `buildToolsVersion` config.
+"${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager" --install "build-tools;35.0.1"
+
+# TODO(jdcormie): Use the same SDK version as build.gradle's compileSdkVersion.
+"${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager" --install "platforms;android-34"
+
+# Bazelisk takes care of installing Bazel.
+mkdir -p /tmp/bazelisk
+curl -Ls -o /tmp/bazelisk/bazelisk https://github.com/bazelbuild/bazelisk/releases/download/v1.19.0/bazelisk-linux-amd64
+chmod +x /tmp/bazelisk/bazelisk
+export PATH=/tmp/bazelisk:$PATH
+
+export USE_BAZEL_VERSION=9.1.0
+bazelisk build \
+ //android \
+ //binder
+
curl -Ls https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3-linux-x86_64.tar.gz | \
tar xz -C /tmp
export PATH=/tmp/cmake-3.26.3-linux-x86_64/bin:$PATH
@@ -132,15 +155,18 @@ fi
# Update the statuses with the deltas
+set +x
gsutil cp gs://grpc-testing-secrets/github_credentials/oauth_token.txt ~/
desc="New DEX reference count: $(printf "%'d" "$new_dex_count") (delta: $(printf "%'d" "$dex_count_delta"))"
+echo "Setting status: $desc"
curl -f -s -X POST -H "Content-Type: application/json" \
-H "Authorization: token $(cat ~/oauth_token.txt | tr -d '\n')" \
-d '{"state": "success", "context": "android/dex_diff", "description": "'"${desc}"'"}' \
"https://api.github.com/repos/grpc/grpc-java/statuses/${KOKORO_GITHUB_PULL_REQUEST_COMMIT}"
desc="New APK size in bytes: $(printf "%'d" "$new_apk_size") (delta: $(printf "%'d" "$apk_size_delta"))"
+echo "Setting status: $desc"
curl -f -s -X POST -H "Content-Type: application/json" \
-H "Authorization: token $(cat ~/oauth_token.txt | tr -d '\n')" \
-d '{"state": "success", "context": "android/apk_diff", "description": "'"${desc}"'"}' \
diff --git a/buildscripts/kokoro/gae-interop.sh b/buildscripts/kokoro/gae-interop.sh
deleted file mode 100755
index c4ce56cac52..00000000000
--- a/buildscripts/kokoro/gae-interop.sh
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/bin/bash
-
-set -exu -o pipefail
-if [[ -f /VERSION ]]; then
- cat /VERSION
-fi
-
-KOKORO_GAE_SERVICE="java-gae-interop-test"
-
-# We deploy as different versions of a single service, this way any stale
-# lingering deploys can be easily cleaned up by purging all running versions
-# of this service.
-KOKORO_GAE_APP_VERSION=$(hostname)
-
-# A dummy version that can be the recipient of all traffic, so that the kokoro test version can be
-# set to 0 traffic. This is a requirement in order to delete it.
-DUMMY_DEFAULT_VERSION='dummy-default'
-
-function cleanup() {
- echo "Performing cleanup now."
- gcloud app services delete $KOKORO_GAE_SERVICE --version $KOKORO_GAE_APP_VERSION --quiet
-}
-trap cleanup SIGHUP SIGINT SIGTERM EXIT
-
-readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
-cd "$GRPC_JAVA_DIR"
-
-##
-## Deploy the dummy 'default' version of the service
-##
-GRADLE_FLAGS="--stacktrace -DgaeStopPreviousVersion=false -PskipCodegen=true -PskipAndroid=true"
-export GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1g'"
-
-# Deploy the dummy 'default' version. We only require that it exists when cleanup() is called.
-# It ok if we race with another run and fail here, because the end result is idempotent.
-set +e
-if ! gcloud app versions describe "$DUMMY_DEFAULT_VERSION" --service="$KOKORO_GAE_SERVICE"; then
- ./gradlew $GRADLE_FLAGS -DgaeDeployVersion="$DUMMY_DEFAULT_VERSION" -DgaePromote=true :grpc-gae-interop-testing-jdk8:appengineDeploy
-else
- echo "default version already exists: $DUMMY_DEFAULT_VERSION"
-fi
-set -e
-
-# Deploy and test the real app (jdk8)
-./gradlew $GRADLE_FLAGS -DgaeDeployVersion="$KOKORO_GAE_APP_VERSION" :grpc-gae-interop-testing-jdk8:runInteropTestRemote
-
-set +e
-echo "Cleaning out stale deploys from previous runs, it is ok if this part fails"
-
-# Sometimes the trap based cleanup fails.
-# Delete all versions whose name is not 'dummy-default' and is older than 1 hour.
-# This expression is an ISO8601 relative date:
-# https://cloud.google.com/sdk/gcloud/reference/topic/datetimes
-gcloud app versions list --format="get(version.id)" --filter="service=$KOKORO_GAE_SERVICE AND NOT version : 'dummy-default' AND version.createTime<'-p1h'" | xargs -i gcloud app services delete "$KOKORO_GAE_SERVICE" --version {} --quiet
-exit 0
diff --git a/buildscripts/kokoro/linux_artifacts.sh b/buildscripts/kokoro/linux_artifacts.sh
index 49d9932dfa0..778826b2fc2 100755
--- a/buildscripts/kokoro/linux_artifacts.sh
+++ b/buildscripts/kokoro/linux_artifacts.sh
@@ -17,7 +17,5 @@ trap spongify_logs EXIT
SKIP_TESTS=true ARCH=aarch_64 /grpc-java/buildscripts/kokoro/unix.sh
"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh grpc-java-artifacts-multiarch env \
SKIP_TESTS=true ARCH=ppcle_64 /grpc-java/buildscripts/kokoro/unix.sh
-# Use a newer GCC version. GCC 7 in multiarch has a bug:
-# internal compiler error: output_operand: invalid %-code
-"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh grpc-java-artifacts-ubuntu2004 env \
+"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh grpc-java-artifacts-multiarch env \
SKIP_TESTS=true ARCH=s390_64 /grpc-java/buildscripts/kokoro/unix.sh
diff --git a/buildscripts/kokoro/macos.cfg b/buildscripts/kokoro/macos.cfg
index a58691a7102..4c79743692e 100644
--- a/buildscripts/kokoro/macos.cfg
+++ b/buildscripts/kokoro/macos.cfg
@@ -2,7 +2,7 @@
# Location of the continuous shell script in repository.
build_file: "grpc-java/buildscripts/kokoro/macos.sh"
-timeout_mins: 45
+timeout_mins: 60
# We always build mvn artifacts.
action {
diff --git a/buildscripts/kokoro/macos.sh b/buildscripts/kokoro/macos.sh
index 018d15dd2f9..58b042fc7d4 100755
--- a/buildscripts/kokoro/macos.sh
+++ b/buildscripts/kokoro/macos.sh
@@ -1,5 +1,6 @@
#!/bin/bash
set -veux -o pipefail
+CMAKE_VERSION=3.31.10
if [[ -f /VERSION ]]; then
cat /VERSION
@@ -7,6 +8,13 @@ fi
readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+DOWNLOAD_DIR=/tmp/source
+mkdir -p ${DOWNLOAD_DIR}
+curl -Ls https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-macos-universal.tar.gz | tar xz -C ${DOWNLOAD_DIR}
+
+curl -Ls https://archive.apache.org/dist/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz |
+ tar xz -C "${DOWNLOAD_DIR}"
+
# We had problems with random tests timing out because it took seconds to do
# trivial (ns) operations. The Kokoro Mac machines have 2 cores with 4 logical
# threads, so Gradle should be using 4 workers by default.
@@ -15,7 +23,7 @@ export GRADLE_FLAGS="${GRADLE_FLAGS:-} --max-workers=2"
. "$GRPC_JAVA_DIR"/buildscripts/kokoro/kokoro.sh
trap spongify_logs EXIT
-export -n JAVA_HOME
-export PATH="$(/usr/libexec/java_home -v"1.8.0")/bin:${PATH}"
+export PATH="/Library/Java/JavaVirtualMachines/jdk-11-latest/Contents/Home/bin:${DOWNLOAD_DIR}/cmake-${CMAKE_VERSION}-macos-universal/CMake.app/Contents/bin:${DOWNLOAD_DIR}/apache-maven-3.8.8/bin:${PATH}"
+unset JAVA_HOME
-"$GRPC_JAVA_DIR"/buildscripts/kokoro/unix.sh
+ARCH=aarch_64 "$GRPC_JAVA_DIR"/buildscripts/kokoro/unix.sh
diff --git a/buildscripts/kokoro/psm-regional_td.cfg b/buildscripts/kokoro/psm-regional_td.cfg
new file mode 100644
index 00000000000..60c7258e2da
--- /dev/null
+++ b/buildscripts/kokoro/psm-regional_td.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 30
+
+action {
+ define_artifacts {
+ regex: "artifacts/**/*sponge_log.xml"
+ regex: "artifacts/**/*.log"
+ strip_prefix: "artifacts"
+ }
+}
+env_vars {
+ key: "PSM_TEST_SUITE"
+ value: "regional_td"
+}
diff --git a/buildscripts/kokoro/unix.sh b/buildscripts/kokoro/unix.sh
index 455d9c07199..693768a0270 100755
--- a/buildscripts/kokoro/unix.sh
+++ b/buildscripts/kokoro/unix.sh
@@ -38,6 +38,7 @@ ARCH="$ARCH" buildscripts/make_dependencies.sh
# Set properties via flags, do not pollute gradle.properties
GRADLE_FLAGS="${GRADLE_FLAGS:-}"
+GRADLE_FLAGS+=" --stacktrace"
GRADLE_FLAGS+=" -PtargetArch=$ARCH"
# For universal binaries on macOS, signal Gradle to use universal flags.
diff --git a/buildscripts/kokoro/upload_artifacts.sh b/buildscripts/kokoro/upload_artifacts.sh
index 39e27eff522..85b267e2329 100644
--- a/buildscripts/kokoro/upload_artifacts.sh
+++ b/buildscripts/kokoro/upload_artifacts.sh
@@ -41,9 +41,9 @@ LOCAL_OTHER_ARTIFACTS="$KOKORO_GFILE_DIR"/github/grpc-java/artifacts/
[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-linux-s390_64.exe' | wc -l)" != '0' ]]
# from macos job:
-[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-osx-x86_64.exe' | wc -l)" != '0' ]]
-# copy all x86 artifacts to aarch until native artifacts are built
-find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-osx-x86_64.exe*' -exec bash -c 'cp "${0}" "${0/x86/aarch}"' {} \;
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-osx-aarch_64.exe' | wc -l)" != '0' ]]
+# copy the universal binaries to x86, as they work on both architectures
+find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-osx-aarch_64.exe*' -exec bash -c 'cp "${0}" "${0/aarch/x86}"' {} \;
# from windows job:
[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-windows-x86_64.exe' | wc -l)" != '0' ]]
diff --git a/buildscripts/kokoro/windows32.bat b/buildscripts/kokoro/windows32.bat
index f87899d0ab8..90c74a57f1a 100644
--- a/buildscripts/kokoro/windows32.bat
+++ b/buildscripts/kokoro/windows32.bat
@@ -25,7 +25,7 @@ cd "%WORKSPACE%"
SET TARGET_ARCH=x86_32
SET FAIL_ON_WARNINGS=true
-SET PROTOBUF_VER=22.5
+SET PROTOBUF_VER=35.1
SET PKG_CONFIG_PATH=%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib\\pkgconfig
SET VC_PROTOBUF_LIBS=/LIBPATH:%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib
SET VC_PROTOBUF_INCLUDE=%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\include
@@ -66,14 +66,16 @@ for /f "tokens=*" %%a in ('pkg-config --libs protobuf') do (
set lib=!lib:~2!
@rem remove spaces
set lib=!lib: =!
- @rem Because protobuf is specified as libprotobuf and elsewhere
- if !lib! NEQ protobuf (
+ set libprefix=!lib:~0,4!
+ if !libprefix!==absl (
set lib=!lib!.lib
- if "!libs_list!"=="" (
- set libs_list=!lib!
- ) else (
- set libs_list=!libs_list!,!lib!
- )
+ ) else (
+ set lib=lib!lib!.lib
+ )
+ if "!libs_list!"=="" (
+ set libs_list=!lib!
+ ) else (
+ set libs_list=!libs_list!,!lib!
)
)
)
diff --git a/buildscripts/kokoro/windows64.bat b/buildscripts/kokoro/windows64.bat
index 0a99f47dd3d..dba07807d03 100644
--- a/buildscripts/kokoro/windows64.bat
+++ b/buildscripts/kokoro/windows64.bat
@@ -24,7 +24,7 @@ cd "%WORKSPACE%"
SET TARGET_ARCH=x86_64
SET FAIL_ON_WARNINGS=true
-SET PROTOBUF_VER=22.5
+SET PROTOBUF_VER=35.1
SET PKG_CONFIG_PATH=%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib\\pkgconfig
SET VC_PROTOBUF_LIBS=/LIBPATH:%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib
SET VC_PROTOBUF_INCLUDE=%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\include
@@ -50,14 +50,16 @@ for /f "tokens=*" %%a in ('pkg-config --libs protobuf') do (
set lib=!lib:~2!
@rem remove spaces
set lib=!lib: =!
- @rem Because protobuf is specified as libprotobuf and elsewhere
- if !lib! NEQ protobuf (
+ set libprefix=!lib:~0,4!
+ if !libprefix!==absl (
set lib=!lib!.lib
- if "!libs_list!"=="" (
- set libs_list=!lib!
- ) else (
- set libs_list=!libs_list!,!lib!
- )
+ ) else (
+ set lib=lib!lib!.lib
+ )
+ if "!libs_list!"=="" (
+ set libs_list=!lib!
+ ) else (
+ set libs_list=!libs_list!,!lib!
)
)
)
diff --git a/buildscripts/make_dependencies.bat b/buildscripts/make_dependencies.bat
index dce08ef7624..4ff775347a5 100644
--- a/buildscripts/make_dependencies.bat
+++ b/buildscripts/make_dependencies.bat
@@ -1,8 +1,8 @@
choco install -y pkgconfiglite
choco install -y openjdk --version=17.0
set PATH=%PATH%;"c:\Program Files\OpenJDK\jdk-17\bin"
-set PROTOBUF_VER=22.5
-set ABSL_VERSION=20230125.4
+set PROTOBUF_VER=35.1
+set ABSL_VERSION=20250127.1
set CMAKE_NAME=cmake-3.26.3-windows-x86_64
if not exist "protobuf-%PROTOBUF_VER%\build\Release\" (
@@ -30,7 +30,6 @@ del protobuf.zip
powershell -command "$ProgressPreference = 'SilentlyContinue'; $ErrorActionPreference = 'stop'; & { [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 ; iwr https://github.com/abseil/abseil-cpp/archive/refs/tags/%ABSL_VERSION%.zip -OutFile absl.zip }" || exit /b 1
powershell -command "$ErrorActionPreference = 'stop'; & { Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory('absl.zip', '.') }" || exit /b 1
del absl.zip
-rmdir protobuf-%PROTOBUF_VER%\third_party\abseil-cpp
move abseil-cpp-%ABSL_VERSION% protobuf-%PROTOBUF_VER%\third_party\abseil-cpp
mkdir protobuf-%PROTOBUF_VER%\build
pushd protobuf-%PROTOBUF_VER%\build
@@ -51,7 +50,7 @@ for /f "tokens=4 delims=\" %%a in ("%VCINSTALLDIR%") do (
for /f "tokens=1 delims=." %%a in ("%VisualStudioVersion%") do (
SET visual_studio_major_version=%%a
)
-cmake -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=%cd%\protobuf-%PROTOBUF_VER% -DCMAKE_PREFIX_PATH=%cd%\protobuf-%PROTOBUF_VER% -G "Visual Studio %visual_studio_major_version% %VC_YEAR%" %CMAKE_VSARCH% .. || exit /b 1
+cmake -DCMAKE_CXX_STANDARD=17 -DABSL_MSVC_STATIC_RUNTIME=ON -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=%cd%\protobuf-%PROTOBUF_VER% -DCMAKE_PREFIX_PATH=%cd%\protobuf-%PROTOBUF_VER% -G "Visual Studio %visual_studio_major_version% %VC_YEAR%" %CMAKE_VSARCH% .. || exit /b 1
cmake --build . --config Release --target install || exit /b 1
popd
goto :eof
diff --git a/buildscripts/make_dependencies.sh b/buildscripts/make_dependencies.sh
index 73cb54b7b68..600e2d40a1b 100755
--- a/buildscripts/make_dependencies.sh
+++ b/buildscripts/make_dependencies.sh
@@ -3,54 +3,33 @@
# Build protoc
set -evux -o pipefail
-PROTOBUF_VERSION=22.5
-ABSL_VERSION=20230125.4
-CMAKE_VERSION=3.26.3
+PROTOBUF_VERSION=35.1
+ABSL_VERSION=20250127.1
# ARCH is x86_64 bit unless otherwise specified.
ARCH="${ARCH:-x86_64}"
DOWNLOAD_DIR=/tmp/source
INSTALL_DIR="/tmp/protobuf-cache/$PROTOBUF_VERSION/$(uname -s)-$ARCH"
BUILDSCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
-mkdir -p $DOWNLOAD_DIR
-cd "$DOWNLOAD_DIR"
-
-# Start with a sane default
-NUM_CPU=4
-if [[ $(uname) == 'Linux' ]]; then
- NUM_CPU=$(nproc)
-fi
-if [[ $(uname) == 'Darwin' ]]; then
- NUM_CPU=$(sysctl -n hw.ncpu)
-fi
-# Make protoc
-# Can't check for presence of directory as cache auto-creates it.
-if [ -f ${INSTALL_DIR}/bin/protoc ]; then
- echo "Not building protobuf. Already built"
-# TODO(ejona): swap to `brew install --devel protobuf` once it is up-to-date
-else
- if [[ ! -d "protobuf-${PROTOBUF_VERSION}" ]]; then
- curl -Ls "https://github.com/google/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-${PROTOBUF_VERSION}.tar.gz" | tar xz
- curl -Ls "https://github.com/abseil/abseil-cpp/archive/refs/tags/${ABSL_VERSION}.tar.gz" | tar xz
- rmdir "protobuf-$PROTOBUF_VERSION/third_party/abseil-cpp"
- mv "abseil-cpp-$ABSL_VERSION" "protobuf-$PROTOBUF_VERSION/third_party/abseil-cpp"
+function build_and_install() {
+ if [[ "$1" == "abseil" ]]; then
+ TESTS_OFF_ARG=ABSL_BUILD_TEST_HELPERS
+ else
+ TESTS_OFF_ARG=protobuf_BUILD_TESTS
fi
- # the same source dir is used for 32 and 64 bit builds, so we need to clean stale data first
- rm -rf "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
- mkdir "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
- pushd "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
- # install here so we don't need sudo
if [[ "$(uname -s)" == "Darwin" ]]; then
cmake .. \
- -DCMAKE_CXX_STANDARD=14 -Dprotobuf_BUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF \
- -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" -DABSL_INTERNAL_AT_LEAST_CXX17=0 \
+ -DCMAKE_CXX_STANDARD=17 -D${TESTS_OFF_ARG}=OFF -DBUILD_SHARED_LIBS=OFF \
+ -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" \
+ -DCMAKE_PREFIX_PATH="$INSTALL_DIR" \
-DCMAKE_OSX_ARCHITECTURES="arm64;x86_64" \
-B. || exit 1
elif [[ "$ARCH" == x86* ]]; then
CFLAGS=-m${ARCH#*_} CXXFLAGS=-m${ARCH#*_} cmake .. \
- -DCMAKE_CXX_STANDARD=14 -Dprotobuf_BUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF \
- -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" -DABSL_INTERNAL_AT_LEAST_CXX17=0 \
+ -DCMAKE_CXX_STANDARD=17 -D${TESTS_OFF_ARG}=OFF -DBUILD_SHARED_LIBS=OFF \
+ -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" \
+ -DCMAKE_PREFIX_PATH="$INSTALL_DIR" \
-B. || exit 1
else
if [[ "$ARCH" == aarch_64 ]]; then
@@ -66,17 +45,56 @@ else
exit 1
fi
cmake .. \
- -DCMAKE_CXX_STANDARD=14 -Dprotobuf_BUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF \
- -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" -DABSL_INTERNAL_AT_LEAST_CXX17=0 \
+ -DCMAKE_CXX_STANDARD=17 -D${TESTS_OFF_ARG}=OFF -DBUILD_SHARED_LIBS=OFF \
+ -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" \
+ -DCMAKE_PREFIX_PATH="$INSTALL_DIR" \
-Dcrosscompile_ARCH="$GCC_ARCH" \
-DCMAKE_TOOLCHAIN_FILE=$BUILDSCRIPTS_DIR/toolchain.cmake \
-B. || exit 1
fi
export CMAKE_BUILD_PARALLEL_LEVEL="$NUM_CPU"
cmake --build . || exit 1
+ # install here so we don't need sudo
cmake --install . || exit 1
- [ -d "$INSTALL_DIR/lib64" ] && mv "$INSTALL_DIR/lib64" "$INSTALL_DIR/lib"
+}
+
+mkdir -p $DOWNLOAD_DIR
+cd "$DOWNLOAD_DIR"
+
+# Start with a sane default
+NUM_CPU=4
+if [[ $(uname) == 'Linux' ]]; then
+ NUM_CPU=$(nproc)
+fi
+if [[ $(uname) == 'Darwin' ]]; then
+ NUM_CPU=$(sysctl -n hw.ncpu)
+fi
+export CMAKE_BUILD_PARALLEL_LEVEL="$NUM_CPU"
+
+# Make protoc
+# Can't check for presence of directory as cache auto-creates it.
+if [ -f ${INSTALL_DIR}/bin/protoc ]; then
+ echo "Not building protobuf. Already built"
+# TODO(ejona): swap to `brew install --devel protobuf` once it is up-to-date
+else
+ if [[ ! -d "protobuf-${PROTOBUF_VERSION}" ]]; then
+ curl -Ls "https://github.com/google/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-${PROTOBUF_VERSION}.tar.gz" | tar xz
+ curl -Ls "https://github.com/abseil/abseil-cpp/archive/refs/tags/${ABSL_VERSION}.tar.gz" | tar xz
+ fi
+ # the same source dir is used for 32 and 64 bit builds, so we need to clean stale data first
+ rm -rf "$DOWNLOAD_DIR/abseil-cpp-${ABSL_VERSION}/build"
+ mkdir "$DOWNLOAD_DIR/abseil-cpp-${ABSL_VERSION}/build"
+ pushd "$DOWNLOAD_DIR/abseil-cpp-${ABSL_VERSION}/build"
+ build_and_install "abseil"
+ popd
+
+ rm -rf "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
+ mkdir "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
+ pushd "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
+ build_and_install "protobuf"
popd
+
+ [ -d "$INSTALL_DIR/lib64" ] && mv "$INSTALL_DIR/lib64" "$INSTALL_DIR/lib"
fi
# If /tmp/protobuf exists then we just assume it's a symlink created by us.
@@ -94,3 +112,4 @@ export CXXFLAGS="$(PKG_CONFIG_PATH=/tmp/protobuf/lib/pkgconfig pkg-config --cfla
export LIBRARY_PATH=/tmp/protobuf/lib
export LD_LIBRARY_PATH=/tmp/protobuf/lib
EOF
+
diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel
index 30ff3ce5dff..a9ffe77a55a 100644
--- a/compiler/BUILD.bazel
+++ b/compiler/BUILD.bazel
@@ -1,5 +1,5 @@
-load("@rules_java//java:defs.bzl", "java_library")
load("@rules_cc//cc:defs.bzl", "cc_binary")
+load("@rules_java//java:defs.bzl", "java_library")
load("@rules_jvm_external//:defs.bzl", "artifact")
load("//:java_grpc_library.bzl", "java_rpc_toolchain")
@@ -13,6 +13,7 @@ cc_binary(
],
visibility = ["//visibility:public"],
deps = [
+ "@abseil-cpp//absl/strings",
"@com_google_protobuf//:protoc_lib",
],
)
diff --git a/compiler/build.gradle b/compiler/build.gradle
index c5acccebae7..f970f629e19 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -76,6 +76,7 @@ model {
aarch_64 { architecture "aarch_64" }
s390_64 { architecture "s390_64" }
loongarch_64 { architecture "loongarch_64" }
+ riscv_64 { architecture "riscv_64" }
}
components {
@@ -84,6 +85,7 @@ model {
'x86_32',
'x86_64',
'ppcle_64',
+ 'riscv_64',
'aarch_64',
's390_64',
'loongarch_64'
@@ -100,7 +102,7 @@ model {
all {
if (toolChain in Gcc || toolChain in Clang) {
cppCompiler.define("GRPC_VERSION", version)
- cppCompiler.args "--std=c++14"
+ cppCompiler.args "--std=c++17"
addEnvArgs("CXXFLAGS", cppCompiler.args)
addEnvArgs("CPPFLAGS", cppCompiler.args)
if (project.hasProperty('buildUniversal') &&
@@ -130,7 +132,7 @@ model {
} else if (toolChain in VisualCpp) {
usingVisualCpp = true
cppCompiler.define("GRPC_VERSION", version)
- cppCompiler.args "/EHsc", "/MT"
+ cppCompiler.args "/EHsc", "/MT", "/std:c++17"
if (rootProject.hasProperty('vcProtobufInclude')) {
cppCompiler.args "/I${rootProject.vcProtobufInclude}"
}
diff --git a/compiler/src/java_plugin/cpp/java_generator.cpp b/compiler/src/java_plugin/cpp/java_generator.cpp
index 659d7ccca47..d0f8cdd13d5 100644
--- a/compiler/src/java_plugin/cpp/java_generator.cpp
+++ b/compiler/src/java_plugin/cpp/java_generator.cpp
@@ -46,6 +46,7 @@
#include