@@ -140,11 +140,11 @@ plugins {
protobuf {
protoc {
- artifact = "com.google.protobuf:protoc:3.19.1"
+ artifact = "com.google.protobuf:protoc:3.19.2"
}
plugins {
grpc {
- artifact = 'io.grpc:protoc-gen-grpc-java:1.43.1'
+ artifact = 'io.grpc:protoc-gen-grpc-java:1.45.0'
}
}
generateProtoTasks {
@@ -173,11 +173,11 @@ plugins {
protobuf {
protoc {
- artifact = "com.google.protobuf:protoc:3.19.1"
+ artifact = "com.google.protobuf:protoc:3.19.2"
}
plugins {
grpc {
- artifact = 'io.grpc:protoc-gen-grpc-java:1.43.1'
+ artifact = 'io.grpc:protoc-gen-grpc-java:1.45.0'
}
}
generateProtoTasks {
diff --git a/RELEASING.md b/RELEASING.md
index f2e37f312b4..b8682961234 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -85,7 +85,7 @@ would be used to create all `v1.7` tags (e.g. `v1.7.0`, `v1.7.1`).
$ echo "## gRPC Java $MAJOR.$MINOR.0 Release Notes" && echo && \
git shortlog "$(git merge-base upstream/v$MAJOR.$((MINOR-1)).x upstream/v$MAJOR.$MINOR.x)"..upstream/v$MAJOR.$MINOR.x | cat && \
echo && echo && echo "Backported commits in previous release:" && \
- git cherry -v v$MAJOR.$((MINOR-1)).0 upstream/v$MAJOR.$MINOR.x | grep ^-
+ git log --oneline "$(git merge-base v$MAJOR.$((MINOR-1)).0 upstream/v$MAJOR.$MINOR.x)"..v$MAJOR.$((MINOR-1)).0^
```
Tagging the Release
@@ -133,7 +133,7 @@ Tagging the Release
$ git commit -a -m "Bump version to $MAJOR.$MINOR.$((PATCH+1))-SNAPSHOT"
```
6. Go through PR review and push the release tag and updated release branch to
- GitHub:
+ GitHub (DO NOT click the merge button on the GitHub page):
```bash
$ git checkout v$MAJOR.$MINOR.x
diff --git a/alts/build.gradle b/alts/build.gradle
index 8c467f51c12..a056799d4f0 100644
--- a/alts/build.gradle
+++ b/alts/build.gradle
@@ -9,9 +9,6 @@ plugins {
description = "gRPC: ALTS"
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
-
evaluationDependsOn(project(':grpc-core').path)
dependencies {
@@ -65,14 +62,14 @@ javadoc {
}
jar {
- // Must use a different classifier to avoid conflicting with shadowJar
- classifier = 'original'
+ // Must use a different archiveClassifier to avoid conflicting with shadowJar
+ archiveClassifier = 'original'
}
// We want to use grpc-netty-shaded instead of grpc-netty. But we also want our
// source to work with Bazel, so we rewrite the code as part of the build.
shadowJar {
- classifier = null
+ archiveClassifier = null
dependencies {
exclude(dependency {true})
}
diff --git a/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java b/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
index 4164560e7a0..e2e7d4046fb 100644
--- a/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
+++ b/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
@@ -21,8 +21,8 @@
import java.util.List;
/**
- * A @{code ChannelCrypterNetty} performs stateful encryption and decryption of independent input
- * and output streams. Both decrypt and encrypt gather their input from a list of Netty @{link
+ * A {@code ChannelCrypterNetty} performs stateful encryption and decryption of independent input
+ * and output streams. Both decrypt and encrypt gather their input from a list of Netty {@link
* ByteBuf} instances.
*
* Note that we provide implementations of this interface that provide integrity only and
diff --git a/alts/src/test/java/io/grpc/alts/internal/TsiTest.java b/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
index f677a44a754..f75fb7fcee0 100644
--- a/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
@@ -34,13 +34,13 @@
import java.util.List;
import javax.crypto.AEADBadTagException;
-/** Utility class that provides tests for implementations of @{link TsiHandshaker}. */
+/** Utility class that provides tests for implementations of {@link TsiHandshaker}. */
public final class TsiTest {
private static final String DECRYPTION_FAILURE_RE = "Tag mismatch!|BAD_DECRYPT";
private TsiTest() {}
- /** A @{code TsiHandshaker} pair for running tests. */
+ /** A {@code TsiHandshaker} pair for running tests. */
public static class Handshakers {
private final TsiHandshaker client;
private final TsiHandshaker server;
diff --git a/android-interop-testing/build.gradle b/android-interop-testing/build.gradle
index b18d84e2625..e40507e6a3b 100644
--- a/android-interop-testing/build.gradle
+++ b/android-interop-testing/build.gradle
@@ -76,8 +76,8 @@ dependencies {
compileOnly libraries.javax_annotation
- androidTestImplementation 'androidx.test:rules:1.1.0-alpha1'
- androidTestImplementation 'androidx.test:runner:1.1.0-alpha1'
+ androidTestImplementation 'androidx.test.ext:junit:1.1.3',
+ 'androidx.test:runner:1.4.0'
}
// Checkstyle doesn't run automatically with android
@@ -102,6 +102,10 @@ tasks.withType(JavaCompile) {
"-Xlint:-cast"
]
appendToProperty(it.options.errorprone.excludedPaths, ".*/R.java", "|")
+ appendToProperty(
+ it.options.errorprone.excludedPaths,
+ ".*/src/generated/.*",
+ "|")
// Reuses source code from grpc-interop-testing, which targets Java 7 (no method references)
options.errorprone.check("UnnecessaryAnonymousClass", CheckSeverity.OFF)
}
diff --git a/android-interop-testing/src/androidTest/AndroidManifest.xml b/android-interop-testing/src/androidTest/AndroidManifest.xml
index 916a1c04332..9c59d201eff 100644
--- a/android-interop-testing/src/androidTest/AndroidManifest.xml
+++ b/android-interop-testing/src/androidTest/AndroidManifest.xml
@@ -6,8 +6,8 @@
android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="io.grpc.android.integrationtest" />
-
-
+
diff --git a/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java b/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java
index abcf9e08593..5d76f1c0a6e 100644
--- a/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java
+++ b/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java
@@ -16,11 +16,12 @@
package io.grpc.android.integrationtest;
-import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertEquals;
import android.util.Log;
-import androidx.test.InstrumentationRegistry;
-import androidx.test.runner.AndroidJUnit4;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
import com.google.android.gms.common.GooglePlayServicesRepairableException;
import com.google.android.gms.security.ProviderInstaller;
@@ -59,7 +60,7 @@ public void setUp() throws Exception {
if (useTls) {
try {
- ProviderInstaller.installIfNeeded(InstrumentationRegistry.getTargetContext());
+ ProviderInstaller.installIfNeeded(ApplicationProvider.getApplicationContext());
} catch (GooglePlayServicesRepairableException e) {
// The provider is helpful, but it is possible to succeed without it.
// Hope that the system-provided libraries are new enough.
@@ -110,7 +111,7 @@ public void onComplete(String result) {
};
InputStream testCa;
if (useTestCa) {
- testCa = InstrumentationRegistry.getTargetContext().getResources().openRawResource(R.raw.ca);
+ testCa = ApplicationProvider.getApplicationContext().getResources().openRawResource(R.raw.ca);
} else {
testCa = null;
}
diff --git a/android/build.gradle b/android/build.gradle
index b0916f9e04c..7e32ac5ca2f 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -59,12 +59,12 @@ task javadocs(type: Javadoc) {
}
task javadocJar(type: Jar, dependsOn: javadocs) {
- classifier = 'javadoc'
+ archiveClassifier = 'javadoc'
from javadocs.destinationDir
}
task sourcesJar(type: Jar) {
- classifier = 'sources'
+ archiveClassifier = 'sources'
from android.sourceSets.main.java.srcDirs
}
diff --git a/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java b/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
index 8c69ca68b5f..dadab1c830c 100644
--- a/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
+++ b/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
@@ -27,6 +27,7 @@
import android.util.Log;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.InlineMe;
import io.grpc.CallOptions;
import io.grpc.ClientCall;
import io.grpc.ConnectivityState;
@@ -90,6 +91,9 @@ public static AndroidChannelBuilder forAddress(String name, int port) {
*/
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/6043")
@Deprecated
+ @InlineMe(
+ replacement = "AndroidChannelBuilder.usingBuilder(builder)",
+ imports = "io.grpc.android.AndroidChannelBuilder")
public static AndroidChannelBuilder fromBuilder(ManagedChannelBuilder builder) {
return usingBuilder(builder);
}
@@ -293,6 +297,13 @@ private class DefaultNetworkCallback extends ConnectivityManager.NetworkCallback
public void onAvailable(Network network) {
delegate.enterIdle();
}
+
+ @Override
+ public void onBlockedStatusChanged(Network network, boolean blocked) {
+ if (!blocked) {
+ delegate.enterIdle();
+ }
+ }
}
/** Respond to network changes. Only used on API levels < 24. */
diff --git a/api/build.gradle b/api/build.gradle
index 1348e49ad60..9f5e6163153 100644
--- a/api/build.gradle
+++ b/api/build.gradle
@@ -12,9 +12,9 @@ evaluationDependsOn(project(':grpc-context').path)
dependencies {
api project(':grpc-context'),
- libraries.jsr305
- implementation libraries.guava,
+ libraries.jsr305,
libraries.errorprone
+ implementation libraries.guava
testImplementation project(':grpc-context').sourceSets.test.output,
project(':grpc-testing'),
@@ -25,7 +25,7 @@ dependencies {
jmh project(':grpc-core')
signature "org.codehaus.mojo.signature:java17:1.0@signature"
- signature "net.sf.androidscents.signature:android-api-level-19:4.4.2_r4@signature"
+ signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
}
javadoc {
diff --git a/api/src/jmh/java/io/grpc/StatusBenchmark.java b/api/src/jmh/java/io/grpc/StatusBenchmark.java
index 846682c3298..e3f087c6204 100644
--- a/api/src/jmh/java/io/grpc/StatusBenchmark.java
+++ b/api/src/jmh/java/io/grpc/StatusBenchmark.java
@@ -16,7 +16,7 @@
package io.grpc;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
@@ -57,7 +57,7 @@ public byte[] messageEncodeEscape() {
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public String messageDecodePlain() {
return Status.MESSAGE_KEY.parseBytes(
- "Unexpected RST in stream".getBytes(StandardCharsets.US_ASCII));
+ "Unexpected RST in stream".getBytes(Charset.forName("US-ASCII")));
}
/**
@@ -68,7 +68,7 @@ public String messageDecodePlain() {
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public String messageDecodeEscape() {
return Status.MESSAGE_KEY.parseBytes(
- "Some Error%10Wasabi and Horseradish are the same".getBytes(StandardCharsets.US_ASCII));
+ "Some Error%10Wasabi and Horseradish are the same".getBytes(Charset.forName("US-ASCII")));
}
/**
@@ -88,7 +88,7 @@ public byte[] codeEncode() {
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Status codeDecode() {
- return Status.CODE_KEY.parseBytes("15".getBytes(StandardCharsets.US_ASCII));
+ return Status.CODE_KEY.parseBytes("15".getBytes(Charset.forName("US-ASCII")));
}
}
diff --git a/api/src/main/java/io/grpc/Attributes.java b/api/src/main/java/io/grpc/Attributes.java
index b70cc2bc8c3..26c2a72f909 100644
--- a/api/src/main/java/io/grpc/Attributes.java
+++ b/api/src/main/java/io/grpc/Attributes.java
@@ -46,11 +46,13 @@
@Immutable
public final class Attributes {
- private final Map, Object> data;
+ private final IdentityHashMap, Object> data;
- public static final Attributes EMPTY = new Attributes(Collections., Object>emptyMap());
+ private static final IdentityHashMap, Object> EMPTY_MAP =
+ new IdentityHashMap, Object>();
+ public static final Attributes EMPTY = new Attributes(EMPTY_MAP);
- private Attributes(Map, Object> data) {
+ private Attributes(IdentityHashMap, Object> data) {
assert data != null;
this.data = data;
}
@@ -212,14 +214,14 @@ public int hashCode() {
*/
public static final class Builder {
private Attributes base;
- private Map, Object> newdata;
+ private IdentityHashMap, Object> newdata;
private Builder(Attributes base) {
assert base != null;
this.base = base;
}
- private Map, Object> data(int size) {
+ private IdentityHashMap, Object> data(int size) {
if (newdata == null) {
newdata = new IdentityHashMap<>(size);
}
@@ -241,7 +243,7 @@ public Builder set(Key key, T value) {
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5777")
public Builder discard(Key key) {
if (base.data.containsKey(key)) {
- Map, Object> newBaseData = new IdentityHashMap<>(base.data);
+ IdentityHashMap, Object> newBaseData = new IdentityHashMap<>(base.data);
newBaseData.remove(key);
base = new Attributes(newBaseData);
}
diff --git a/api/src/main/java/io/grpc/CallOptions.java b/api/src/main/java/io/grpc/CallOptions.java
index c7504a6506a..5c05d5b7bd7 100644
--- a/api/src/main/java/io/grpc/CallOptions.java
+++ b/api/src/main/java/io/grpc/CallOptions.java
@@ -358,6 +358,11 @@ public T getOption(Key key) {
return key.defaultValue;
}
+ /**
+ * Returns the executor override to use for this specific call, or {@code null} if there is no
+ * override. The executor is only for servicing this one call, so is not safe to use after
+ * {@link ClientCall.Listener#onClose}.
+ */
@Nullable
public Executor getExecutor() {
return executor;
diff --git a/api/src/main/java/io/grpc/DecompressorRegistry.java b/api/src/main/java/io/grpc/DecompressorRegistry.java
index b2669d3c0fc..ea0433d8d0a 100644
--- a/api/src/main/java/io/grpc/DecompressorRegistry.java
+++ b/api/src/main/java/io/grpc/DecompressorRegistry.java
@@ -20,7 +20,7 @@
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.Joiner;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
@@ -85,7 +85,7 @@ private DecompressorRegistry(Decompressor d, boolean advertised, DecompressorReg
decompressors = Collections.unmodifiableMap(newDecompressors);
advertisedDecompressors = ACCEPT_ENCODING_JOINER.join(getAdvertisedMessageEncodings())
- .getBytes(StandardCharsets.US_ASCII);
+ .getBytes(Charset.forName("US-ASCII"));
}
private DecompressorRegistry() {
diff --git a/api/src/main/java/io/grpc/InternalManagedChannelProvider.java b/api/src/main/java/io/grpc/InternalManagedChannelProvider.java
new file mode 100644
index 00000000000..076b5464b7e
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalManagedChannelProvider.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2022 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 io.grpc.ManagedChannelProvider.NewChannelBuilderResult;
+
+/** Internal accessor for {@link ManagedChannelProvider}. */
+@Internal
+public final class InternalManagedChannelProvider {
+
+ private InternalManagedChannelProvider() {
+ }
+
+ public static ManagedChannelBuilder builderForAddress(ManagedChannelProvider provider,
+ String name, int port) {
+ return provider.builderForAddress(name, port);
+ }
+
+ public static ManagedChannelBuilder builderForTarget(ManagedChannelProvider provider,
+ String target) {
+ return provider.builderForTarget(target);
+ }
+
+ public static NewChannelBuilderResult newChannelBuilder(ManagedChannelProvider provider,
+ String target, ChannelCredentials creds) {
+ return provider.newChannelBuilder(target, creds);
+ }
+}
diff --git a/api/src/main/java/io/grpc/InternalMetadata.java b/api/src/main/java/io/grpc/InternalMetadata.java
index cb98ad752b2..2823882952f 100644
--- a/api/src/main/java/io/grpc/InternalMetadata.java
+++ b/api/src/main/java/io/grpc/InternalMetadata.java
@@ -20,7 +20,6 @@
import io.grpc.Metadata.AsciiMarshaller;
import io.grpc.Metadata.BinaryStreamMarshaller;
import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
/**
* Internal {@link Metadata} accessor. This is intended for use by io.grpc.internal, and the
@@ -43,7 +42,7 @@ public interface TrustedAsciiMarshaller extends Metadata.TrustedAsciiMarshall
* Copy of StandardCharsets, which is only available on Java 1.7 and above.
*/
@Internal
- public static final Charset US_ASCII = StandardCharsets.US_ASCII;
+ public static final Charset US_ASCII = Charset.forName("US-ASCII");
/**
* An instance of base64 encoder that omits padding.
diff --git a/api/src/main/java/io/grpc/InternalServerProvider.java b/api/src/main/java/io/grpc/InternalServerProvider.java
new file mode 100644
index 00000000000..d8c1d77fe76
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalServerProvider.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 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 io.grpc.ServerProvider.NewServerBuilderResult;
+
+/** Internal accessor for {@link ServerProvider}. */
+@Internal
+public final class InternalServerProvider {
+
+ private InternalServerProvider() {
+ }
+
+ public static ServerBuilder builderForPort(ServerProvider provider, int port) {
+ return provider.builderForPort(port);
+ }
+
+ public static NewServerBuilderResult newServerBuilderForPort(ServerProvider provider, int port,
+ ServerCredentials creds) {
+ return provider.newServerBuilderForPort(port, creds);
+ }
+}
diff --git a/api/src/main/java/io/grpc/NameResolver.java b/api/src/main/java/io/grpc/NameResolver.java
index f4c05aa6a64..78b35a14e38 100644
--- a/api/src/main/java/io/grpc/NameResolver.java
+++ b/api/src/main/java/io/grpc/NameResolver.java
@@ -21,6 +21,7 @@
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
+import com.google.errorprone.annotations.InlineMe;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@@ -204,6 +205,10 @@ public abstract static class Listener2 implements Listener {
*/
@Override
@Deprecated
+ @InlineMe(
+ replacement = "this.onResult(ResolutionResult.newBuilder().setAddresses(servers)"
+ + ".setAttributes(attributes).build())",
+ imports = "io.grpc.NameResolver.ResolutionResult")
public final void onAddresses(
List servers, @ResolutionResultAttr Attributes attributes) {
// TODO(jihuncho) need to promote Listener2 if we want to use ConfigOrError
diff --git a/api/src/test/java/io/grpc/StatusTest.java b/api/src/test/java/io/grpc/StatusTest.java
index aca5dc8ee66..9abeba436f7 100644
--- a/api/src/test/java/io/grpc/StatusTest.java
+++ b/api/src/test/java/io/grpc/StatusTest.java
@@ -21,8 +21,6 @@
import io.grpc.Status.Code;
import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -30,7 +28,7 @@
/** Unit tests for {@link Status}. */
@RunWith(JUnit4.class)
public class StatusTest {
- private final Charset ascii = StandardCharsets.US_ASCII;
+ private final Charset ascii = Charset.forName("US-ASCII");
@Test
public void verifyExceptionMessage() {
diff --git a/auth/build.gradle b/auth/build.gradle
index 791402fce59..233de359b49 100644
--- a/auth/build.gradle
+++ b/auth/build.gradle
@@ -14,5 +14,5 @@ dependencies {
testImplementation project(':grpc-testing'),
libraries.google_auth_oauth2_http
signature "org.codehaus.mojo.signature:java17:1.0@signature"
- signature "net.sf.androidscents.signature:android-api-level-19:4.4.2_r4@signature"
+ signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
}
diff --git a/authz/build.gradle b/authz/build.gradle
new file mode 100644
index 00000000000..f6110a5850c
--- /dev/null
+++ b/authz/build.gradle
@@ -0,0 +1,77 @@
+plugins {
+ id "java-library"
+ id "maven-publish"
+
+ id "com.github.johnrengelman.shadow"
+ id "com.google.protobuf"
+ id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Authorization"
+
+dependencies {
+ implementation project(':grpc-protobuf'),
+ project(':grpc-core')
+
+ annotationProcessor libraries.autovalue
+ compileOnly libraries.javax_annotation
+
+ testImplementation project(':grpc-testing'),
+ project(':grpc-testing-proto')
+ testImplementation (libraries.guava_testlib) {
+ exclude group: 'junit', module: 'junit'
+ }
+
+ def xdsDependency = implementation project(':grpc-xds')
+ shadow configurations.implementation.getDependencies().minus([xdsDependency])
+ shadow project(path: ':grpc-xds', configuration: 'shadow')
+
+ signature "org.codehaus.mojo.signature:java17:1.0@signature"
+}
+
+jar {
+ classifier = 'original'
+}
+
+// TODO(ashithasantosh): Remove javadoc exclusion on adding authorization
+// interceptor implementations.
+javadoc {
+ exclude "io/grpc/authz/*"
+}
+
+shadowJar {
+ classifier = null
+ dependencies {
+ exclude(dependency {true})
+ }
+ relocate 'io.grpc.xds', 'io.grpc.xds.shaded.io.grpc.xds'
+ relocate 'udpa.annotations', 'io.grpc.xds.shaded.udpa.annotations'
+ relocate 'com.github.udpa', 'io.grpc.xds.shaded.com.github.udpa'
+ relocate 'envoy.annotations', 'io.grpc.xds.shaded.envoy.annotations'
+ relocate 'io.envoyproxy', 'io.grpc.xds.shaded.io.envoyproxy'
+ relocate 'com.google.api.expr', 'io.grpc.xds.shaded.com.google.api.expr'
+}
+
+publishing {
+ publications {
+ maven(MavenPublication) {
+ // We want this to throw an exception if it isn't working
+ def originalJar = artifacts.find { dep -> dep.classifier == 'original'}
+ artifacts.remove(originalJar)
+
+ pom.withXml {
+ def dependenciesNode = new Node(null, 'dependencies')
+ project.configurations.shadow.allDependencies.each { dep ->
+ def dependencyNode = dependenciesNode.appendNode('dependency')
+ dependencyNode.appendNode('groupId', dep.group)
+ dependencyNode.appendNode('artifactId', dep.name)
+ dependencyNode.appendNode('version', dep.version)
+ dependencyNode.appendNode('scope', 'compile')
+ }
+ asNode().dependencies[0].replaceNode(dependenciesNode)
+ }
+ }
+ }
+}
+
+[publishMavenPublicationToMavenRepository]*.onlyIf {false}
diff --git a/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java b/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java
new file mode 100644
index 00000000000..1637af737ad
--- /dev/null
+++ b/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2021 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.authz;
+
+import com.google.common.collect.ImmutableList;
+import io.envoyproxy.envoy.config.rbac.v3.Permission;
+import io.envoyproxy.envoy.config.rbac.v3.Policy;
+import io.envoyproxy.envoy.config.rbac.v3.Principal;
+import io.envoyproxy.envoy.config.rbac.v3.Principal.Authenticated;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC.Action;
+import io.envoyproxy.envoy.config.route.v3.HeaderMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.PathMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.JsonUtil;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Translates a gRPC authorization policy in JSON string to Envoy RBAC policies.
+ */
+class AuthorizationPolicyTranslator {
+ private static final ImmutableList UNSUPPORTED_HEADERS = ImmutableList.of(
+ "host", "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
+ "te", "trailer", "transfer-encoding", "upgrade");
+
+ private static StringMatcher getStringMatcher(String value) {
+ if (value.equals("*")) {
+ return StringMatcher.newBuilder().setSafeRegex(
+ RegexMatcher.newBuilder().setRegex(".+").build()).build();
+ } else if (value.startsWith("*")) {
+ return StringMatcher.newBuilder().setSuffix(value.substring(1)).build();
+ } else if (value.endsWith("*")) {
+ return StringMatcher.newBuilder().setPrefix(value.substring(0, value.length() - 1)).build();
+ }
+ return StringMatcher.newBuilder().setExact(value).build();
+ }
+
+ private static Principal parseSource(Map source) {
+ List principalsList = JsonUtil.getListOfStrings(source, "principals");
+ if (principalsList == null || principalsList.isEmpty()) {
+ return Principal.newBuilder().setAny(true).build();
+ }
+ Principal.Set.Builder principalsSet = Principal.Set.newBuilder();
+ for (String principal: principalsList) {
+ principalsSet.addIds(
+ Principal.newBuilder().setAuthenticated(
+ Authenticated.newBuilder().setPrincipalName(
+ getStringMatcher(principal)).build()).build());
+ }
+ return Principal.newBuilder().setOrIds(principalsSet.build()).build();
+ }
+
+ private static Permission parseHeader(Map header) throws IllegalArgumentException {
+ String key = JsonUtil.getString(header, "key");
+ if (key == null || key.isEmpty()) {
+ throw new IllegalArgumentException("\"key\" is absent or empty");
+ }
+ if (key.charAt(0) == ':'
+ || key.startsWith("grpc-")
+ || UNSUPPORTED_HEADERS.contains(key.toLowerCase())) {
+ throw new IllegalArgumentException(String.format("Unsupported \"key\" %s", key));
+ }
+ List valuesList = JsonUtil.getListOfStrings(header, "values");
+ if (valuesList == null || valuesList.isEmpty()) {
+ throw new IllegalArgumentException("\"values\" is absent or empty");
+ }
+ Permission.Set.Builder orSet = Permission.Set.newBuilder();
+ for (String value: valuesList) {
+ orSet.addRules(
+ Permission.newBuilder().setHeader(
+ HeaderMatcher.newBuilder()
+ .setName(key)
+ .setStringMatch(getStringMatcher(value)).build()).build());
+ }
+ return Permission.newBuilder().setOrRules(orSet.build()).build();
+ }
+
+ private static Permission parseRequest(Map request) throws IllegalArgumentException {
+ Permission.Set.Builder andSet = Permission.Set.newBuilder();
+ List pathsList = JsonUtil.getListOfStrings(request, "paths");
+ if (pathsList != null && !pathsList.isEmpty()) {
+ Permission.Set.Builder pathsSet = Permission.Set.newBuilder();
+ for (String path: pathsList) {
+ pathsSet.addRules(
+ Permission.newBuilder().setUrlPath(
+ PathMatcher.newBuilder().setPath(
+ getStringMatcher(path)).build()).build());
+ }
+ andSet.addRules(Permission.newBuilder().setOrRules(pathsSet.build()).build());
+ }
+ List> headersList = JsonUtil.getListOfObjects(request, "headers");
+ if (headersList != null && !headersList.isEmpty()) {
+ Permission.Set.Builder headersSet = Permission.Set.newBuilder();
+ for (Map header: headersList) {
+ headersSet.addRules(parseHeader(header));
+ }
+ andSet.addRules(Permission.newBuilder().setAndRules(headersSet.build()).build());
+ }
+ if (andSet.getRulesCount() == 0) {
+ return Permission.newBuilder().setAny(true).build();
+ }
+ return Permission.newBuilder().setAndRules(andSet.build()).build();
+ }
+
+ private static Map parseRules(
+ List> objects, String name) throws IllegalArgumentException {
+ Map policies = new LinkedHashMap();
+ for (Map object: objects) {
+ String policyName = JsonUtil.getString(object, "name");
+ if (policyName == null || policyName.isEmpty()) {
+ throw new IllegalArgumentException("rule \"name\" is absent or empty");
+ }
+ List principals = new ArrayList<>();
+ Map source = JsonUtil.getObject(object, "source");
+ if (source != null) {
+ principals.add(parseSource(source));
+ } else {
+ principals.add(Principal.newBuilder().setAny(true).build());
+ }
+ List permissions = new ArrayList<>();
+ Map request = JsonUtil.getObject(object, "request");
+ if (request != null) {
+ permissions.add(parseRequest(request));
+ } else {
+ permissions.add(Permission.newBuilder().setAny(true).build());
+ }
+ Policy policy =
+ Policy.newBuilder()
+ .addAllPermissions(permissions)
+ .addAllPrincipals(principals)
+ .build();
+ policies.put(name + "_" + policyName, policy);
+ }
+ return policies;
+ }
+
+ /**
+ * 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()));
+ }
+ @SuppressWarnings("unchecked")
+ Map json = (Map)jsonObject;
+ String name = JsonUtil.getString(json, "name");
+ if (name == null || name.isEmpty()) {
+ throw new IllegalArgumentException("\"name\" is absent or empty");
+ }
+ List rbacs = new ArrayList<>();
+ List> objects = JsonUtil.getListOfObjects(json, "deny_rules");
+ if (objects != null && !objects.isEmpty()) {
+ rbacs.add(
+ RBAC.newBuilder()
+ .setAction(Action.DENY)
+ .putAllPolicies(parseRules(objects, name))
+ .build());
+ }
+ objects = JsonUtil.getListOfObjects(json, "allow_rules");
+ if (objects == null || objects.isEmpty()) {
+ throw new IllegalArgumentException("\"allow_rules\" is absent");
+ }
+ rbacs.add(
+ RBAC.newBuilder()
+ .setAction(Action.ALLOW)
+ .putAllPolicies(parseRules(objects, name))
+ .build());
+ return rbacs;
+ }
+}
diff --git a/authz/src/test/java/io/grpc/authz/AuthorizationPolicyTranslatorTest.java b/authz/src/test/java/io/grpc/authz/AuthorizationPolicyTranslatorTest.java
new file mode 100644
index 00000000000..b957bf283e7
--- /dev/null
+++ b/authz/src/test/java/io/grpc/authz/AuthorizationPolicyTranslatorTest.java
@@ -0,0 +1,574 @@
+/*
+ * Copyright 2021 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.authz;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import io.envoyproxy.envoy.config.rbac.v3.Permission;
+import io.envoyproxy.envoy.config.rbac.v3.Policy;
+import io.envoyproxy.envoy.config.rbac.v3.Principal;
+import io.envoyproxy.envoy.config.rbac.v3.Principal.Authenticated;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC.Action;
+import io.envoyproxy.envoy.config.route.v3.HeaderMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.PathMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import java.io.IOException;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AuthorizationPolicyTranslatorTest {
+ @Test
+ public void invalidPolicy() throws Exception {
+ String policy = "{ \"name\": \"abc\",, }";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IOException ioe) {
+ assertThat(ioe).hasMessageThat().isEqualTo(
+ "Use JsonReader.setLenient(true) to accept malformed JSON"
+ + " at line 1 column 18 path $.name");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void missingAuthorizationPolicyName() throws Exception {
+ String policy = "{}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("\"name\" is absent or empty");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void incorrectAuthorizationPolicyName() throws Exception {
+ String policy = "{ \"name\": [\"abc\"] }";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (ClassCastException cce) {
+ assertThat(cce).hasMessageThat().isEqualTo(
+ "value '[abc]' for key 'name' in '{name=[abc]}' is not String");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void missingAllowRules() throws Exception {
+ String policy = "{ \"name\": \"authz\" }";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("\"allow_rules\" is absent");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void missingRuleName() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"abc\" ,"
+ + " \"allow_rules\" : ["
+ + " {}"
+ + " ]"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("rule \"name\" is absent or empty");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void missingSourceAndRequest() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\" : ["
+ + " {"
+ + " \"name\": \"allow_all\""
+ + " }"
+ + " ]"
+ + "}";
+ List rbacs = AuthorizationPolicyTranslator.translate(policy);
+ assertEquals(1, rbacs.size());
+ RBAC expected_rbac =
+ RBAC.newBuilder()
+ .setAction(Action.ALLOW)
+ .putPolicies("authz_allow_all",
+ Policy.newBuilder()
+ .addPrincipals(Principal.newBuilder().setAny(true))
+ .addPermissions(Permission.newBuilder().setAny(true))
+ .build())
+ .build();
+ assertEquals(expected_rbac, rbacs.get(0));
+ }
+
+ @Test
+ public void emptySourceAndRequest() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\" : ["
+ + " {"
+ + " \"name\": \"allow_all\","
+ + " \"source\": {},"
+ + " \"request\": {}"
+ + " }"
+ + " ]"
+ + "}";
+ List rbacs = AuthorizationPolicyTranslator.translate(policy);
+ assertEquals(1, rbacs.size());
+ RBAC expected_rbac =
+ RBAC.newBuilder()
+ .setAction(Action.ALLOW)
+ .putPolicies("authz_allow_all",
+ Policy.newBuilder()
+ .addPrincipals(Principal.newBuilder().setAny(true))
+ .addPermissions(Permission.newBuilder().setAny(true))
+ .build())
+ .build();
+ assertEquals(expected_rbac, rbacs.get(0));
+ }
+
+ @Test
+ public void incorrectRulesType() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"abc\" ,"
+ + " \"allow_rules\" : {}"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (ClassCastException cce) {
+ assertThat(cce).hasMessageThat().isEqualTo(
+ "value '{}' for key 'allow_rules' in '{name=abc, allow_rules={}}' is not List");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void parseSourceSuccess() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"deny_rules\": ["
+ + " {"
+ + " \"name\": \"deny_users\","
+ + " \"source\": {"
+ + " \"principals\": ["
+ + " \"spiffe://foo.com\","
+ + " \"spiffe://bar*\","
+ + " \"*baz\","
+ + " \"spiffe://*.com\""
+ + " ]"
+ + " }"
+ + " }"
+ + " ],"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_any\","
+ + " \"source\": {"
+ + " \"principals\": ["
+ + " \"*\""
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ List rbacs = AuthorizationPolicyTranslator.translate(policy);
+ assertEquals(2, rbacs.size());
+ RBAC expected_deny_rbac =
+ RBAC.newBuilder()
+ .setAction(Action.DENY)
+ .putPolicies("authz_deny_users",
+ Policy.newBuilder()
+ .addPrincipals(Principal.newBuilder()
+ .setOrIds(
+ Principal.Set.newBuilder()
+ .addIds(Principal.newBuilder()
+ .setAuthenticated(Authenticated.newBuilder()
+ .setPrincipalName(StringMatcher.newBuilder()
+ .setExact("spiffe://foo.com").build()).build()).build())
+ .addIds(Principal.newBuilder()
+ .setAuthenticated(Authenticated.newBuilder()
+ .setPrincipalName(StringMatcher.newBuilder()
+ .setPrefix("spiffe://bar").build()).build()).build())
+ .addIds(Principal.newBuilder()
+ .setAuthenticated(Authenticated.newBuilder()
+ .setPrincipalName(StringMatcher.newBuilder()
+ .setSuffix("baz").build()).build()).build())
+ .addIds(Principal.newBuilder()
+ .setAuthenticated(Authenticated.newBuilder()
+ .setPrincipalName(StringMatcher.newBuilder()
+ .setExact("spiffe://*.com").build()).build()).build())
+ .build()).build())
+ .addPermissions(Permission.newBuilder().setAny(true))
+ .build()).build();
+ RBAC expected_allow_rbac =
+ RBAC.newBuilder()
+ .setAction(Action.ALLOW)
+ .putPolicies("authz_allow_any",
+ Policy.newBuilder()
+ .addPrincipals(Principal.newBuilder()
+ .setOrIds(
+ Principal.Set.newBuilder()
+ .addIds(Principal.newBuilder()
+ .setAuthenticated(Authenticated.newBuilder()
+ .setPrincipalName(StringMatcher.newBuilder()
+ .setSafeRegex(RegexMatcher.newBuilder()
+ .setRegex(".+").build()).build()).build())
+ .build())
+ .build()).build())
+ .addPermissions(Permission.newBuilder().setAny(true))
+ .build()).build();
+ assertEquals(expected_deny_rbac, rbacs.get(0));
+ assertEquals(expected_allow_rbac, rbacs.get(1));
+ }
+
+ @Test
+ public void unsupportedPseudoHeaders() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_access\","
+ + " \"request\": {"
+ + " \"headers\": ["
+ + " {"
+ + " \"key\": \":method\","
+ + " \"values\": ["
+ + " \"foo\""
+ + " ]"
+ + " }"
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("Unsupported \"key\" :method");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void unsupportedGrpcPrefixHeaders() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_access\","
+ + " \"request\": {"
+ + " \"headers\": ["
+ + " {"
+ + " \"key\": \"grpc-xxx\","
+ + " \"values\": ["
+ + " \"foo\""
+ + " ]"
+ + " }"
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("Unsupported \"key\" grpc-xxx");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void unsupportedHostHeaders() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_access\","
+ + " \"request\": {"
+ + " \"headers\": ["
+ + " {"
+ + " \"key\": \"Host\","
+ + " \"values\": ["
+ + " \"foo\""
+ + " ]"
+ + " }"
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("Unsupported \"key\" Host");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void missingHeaderKey() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_dev\","
+ + " \"request\": {"
+ + " \"headers\": ["
+ + " {}"
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("\"key\" is absent or empty");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void missingHeaderValues() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_dev\","
+ + " \"request\": {"
+ + " \"headers\": ["
+ + " {"
+ + " \"key\": \"dev-path\""
+ + " }"
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("\"values\" is absent or empty");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void emptyHeaderValues() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_dev\","
+ + " \"request\": {"
+ + " \"headers\": ["
+ + " {"
+ + " \"key\": \"dev-path\","
+ + " \"values\": []"
+ + " }"
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ try {
+ AuthorizationPolicyTranslator.translate(policy);
+ fail("exception expected");
+ } catch (IllegalArgumentException iae) {
+ assertThat(iae).hasMessageThat().isEqualTo("\"values\" is absent or empty");
+ } catch (Exception e) {
+ throw new AssertionError("the test failed ", e);
+ }
+ }
+
+ @Test
+ public void parseRequestSuccess() throws Exception {
+ String policy = "{"
+ + " \"name\" : \"authz\" ,"
+ + " \"deny_rules\": ["
+ + " {"
+ + " \"name\": \"deny_access\","
+ + " \"request\": {"
+ + " \"paths\": ["
+ + " \"/pkg.service/foo\","
+ + " \"/pkg.service/bar*\""
+ + " ],"
+ + " \"headers\": ["
+ + " {"
+ + " \"key\": \"dev-path\","
+ + " \"values\": [\"/dev/path/*\"]"
+ + " }"
+ + " ]"
+ + " }"
+ + " }"
+ + " ],"
+ + " \"allow_rules\": ["
+ + " {"
+ + " \"name\": \"allow_access1\","
+ + " \"request\": {"
+ + " \"headers\": ["
+ + " {"
+ + " \"key\": \"key-1\","
+ + " \"values\": ["
+ + " \"foo\","
+ + " \"*bar\""
+ + " ]"
+ + " },"
+ + " {"
+ + " \"key\": \"key-2\","
+ + " \"values\": ["
+ + " \"*\""
+ + " ]"
+ + " }"
+ + " ]"
+ + " }"
+ + " },"
+ + " {"
+ + " \"name\": \"allow_access2\","
+ + " \"request\": {"
+ + " \"paths\": ["
+ + " \"*baz\""
+ + " ]"
+ + " }"
+ + " }"
+ + " ]"
+ + "}";
+ List rbacs = AuthorizationPolicyTranslator.translate(policy);
+ assertEquals(2, rbacs.size());
+ RBAC expected_deny_rbac =
+ RBAC.newBuilder()
+ .setAction(Action.DENY)
+ .putPolicies("authz_deny_access",
+ Policy.newBuilder()
+ .addPermissions(Permission.newBuilder()
+ .setAndRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setOrRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setUrlPath(PathMatcher.newBuilder()
+ .setPath(StringMatcher.newBuilder()
+ .setExact("/pkg.service/foo").build()).build()).build())
+ .addRules(Permission.newBuilder()
+ .setUrlPath(PathMatcher.newBuilder()
+ .setPath(StringMatcher.newBuilder()
+ .setPrefix("/pkg.service/bar").build()).build()).build())
+ .build()).build())
+ .addRules(Permission.newBuilder()
+ .setAndRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setOrRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setHeader(HeaderMatcher.newBuilder()
+ .setName("dev-path")
+ .setStringMatch(StringMatcher.newBuilder()
+ .setPrefix("/dev/path/").build())
+ .build())
+ .build())
+ .build()).build())
+ .build()).build())
+ .build()))
+ .addPrincipals(Principal.newBuilder().setAny(true))
+ .build()).build();
+ RBAC expected_allow_rbac =
+ RBAC.newBuilder()
+ .setAction(Action.ALLOW)
+ .putPolicies("authz_allow_access1",
+ Policy.newBuilder()
+ .addPermissions(Permission.newBuilder()
+ .setAndRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setAndRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setOrRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setHeader(HeaderMatcher.newBuilder()
+ .setName("key-1")
+ .setStringMatch(StringMatcher.newBuilder()
+ .setExact("foo").build())
+ .build())
+ .build())
+ .addRules(Permission.newBuilder()
+ .setHeader(HeaderMatcher.newBuilder()
+ .setName("key-1")
+ .setStringMatch(StringMatcher.newBuilder()
+ .setSuffix("bar").build())
+ .build())
+ .build())
+ .build()).build())
+ .addRules(Permission.newBuilder()
+ .setOrRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setHeader(HeaderMatcher.newBuilder()
+ .setName("key-2")
+ .setStringMatch(StringMatcher.newBuilder()
+ .setSafeRegex(RegexMatcher.newBuilder()
+ .setRegex(".+").build()).build())
+ .build())
+ .build())
+ .build()).build()).build()).build()).build()))
+ .addPrincipals(Principal.newBuilder().setAny(true))
+ .build())
+ .putPolicies("authz_allow_access2",
+ Policy.newBuilder()
+ .addPermissions(Permission.newBuilder()
+ .setAndRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setOrRules(Permission.Set.newBuilder()
+ .addRules(Permission.newBuilder()
+ .setUrlPath(PathMatcher.newBuilder()
+ .setPath(StringMatcher.newBuilder()
+ .setSuffix("baz").build()).build()).build())
+ .build()).build())
+ .build()))
+ .addPrincipals(Principal.newBuilder().setAny(true))
+ .build())
+ .build();
+ assertEquals(expected_deny_rbac, rbacs.get(0));
+ assertEquals(expected_allow_rbac, rbacs.get(1));
+ }
+}
diff --git a/benchmarks/build.gradle b/benchmarks/build.gradle
index 48b9030714f..c8a8669dd1f 100644
--- a/benchmarks/build.gradle
+++ b/benchmarks/build.gradle
@@ -27,6 +27,7 @@ dependencies {
project(':grpc-stub'),
project(':grpc-protobuf'),
project(':grpc-testing'),
+ project(path: ':grpc-xds', configuration: 'shadow'),
libraries.hdrhistogram,
libraries.netty_tcnative,
libraries.netty_epoll,
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java b/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
index 6c6d597cd5e..c35cc7e5c38 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
@@ -33,6 +33,11 @@ public interface SocketAddressValidator {
public boolean isValidSocketAddress(SocketAddress address) {
return address instanceof InetSocketAddress;
}
+
+ @Override
+ public boolean isValidSocketAddress(String address) {
+ return !address.startsWith("unix://");
+ }
};
/**
@@ -43,10 +48,20 @@ public boolean isValidSocketAddress(SocketAddress address) {
public boolean isValidSocketAddress(SocketAddress address) {
return "DomainSocketAddress".equals(address.getClass().getSimpleName());
}
+
+ @Override
+ public boolean isValidSocketAddress(String address) {
+ return address.startsWith("unix://");
+ }
};
/**
* Returns {@code true} if the given address is valid.
*/
boolean isValidSocketAddress(SocketAddress address);
+
+ /**
+ * Returns {@code true} if the given address is valid.
+ */
+ boolean isValidSocketAddress(String address);
}
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java b/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
index 0097bd9dd20..820b3ac1968 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
@@ -16,8 +16,6 @@
package io.grpc.benchmarks;
-import java.net.SocketAddress;
-
/**
* All of the supported transports.
*/
@@ -49,7 +47,7 @@ public enum Transport {
*
* @throws IllegalArgumentException if the given address is invalid for this transport.
*/
- public void validateSocketAddress(SocketAddress address) {
+ public void validateSocketAddress(String address) {
if (!socketAddressValidator.isValidSocketAddress(address)) {
throw new IllegalArgumentException(
"Invalid address " + address + " for transport " + this);
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java b/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
index 9a3d1f6bc24..8087afbf406 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
@@ -18,20 +18,22 @@
import static java.util.concurrent.ForkJoinPool.defaultForkJoinWorkerThreadFactory;
+import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.UncaughtExceptionHandlers;
import com.google.protobuf.ByteString;
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Status;
+import io.grpc.TlsChannelCredentials;
import io.grpc.benchmarks.proto.Messages;
import io.grpc.benchmarks.proto.Messages.Payload;
import io.grpc.benchmarks.proto.Messages.SimpleRequest;
import io.grpc.benchmarks.proto.Messages.SimpleResponse;
-import io.grpc.internal.testing.TestUtils;
-import io.grpc.netty.GrpcSslContexts;
import io.grpc.netty.NettyChannelBuilder;
import io.grpc.okhttp.OkHttpChannelBuilder;
-import io.grpc.okhttp.internal.Platform;
+import io.grpc.testing.TlsTesting;
import io.netty.channel.epoll.EpollDomainSocketChannel;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollSocketChannel;
@@ -79,15 +81,10 @@ public static boolean parseBoolean(String value) {
/**
* Parse a {@link SocketAddress} from the given string.
*/
- public static SocketAddress parseSocketAddress(String value) {
+ public static SocketAddress parseServerSocketAddress(String value) {
if (value.startsWith(UNIX_DOMAIN_SOCKET_PREFIX)) {
- // Unix Domain Socket address.
- // Create the underlying file for the Unix Domain Socket.
- String filePath = value.substring(UNIX_DOMAIN_SOCKET_PREFIX.length());
- File file = new File(filePath);
- if (!file.isAbsolute()) {
- throw new IllegalArgumentException("File path must be absolute: " + filePath);
- }
+ DomainSocketAddress domainAddress = parseUnixSocketAddress(value);
+ File file = new File(domainAddress.path());
try {
if (file.createNewFile()) {
// If this application created the file, delete it when the application exits.
@@ -96,8 +93,7 @@ public static SocketAddress parseSocketAddress(String value) {
} catch (IOException ex) {
throw new RuntimeException(ex);
}
- // Create the SocketAddress referencing the file.
- return new DomainSocketAddress(file);
+ return domainAddress;
} else {
// Standard TCP/IP address.
String[] parts = value.split(":", 2);
@@ -111,37 +107,24 @@ public static SocketAddress parseSocketAddress(String value) {
}
}
- private static OkHttpChannelBuilder newOkHttpClientChannel(
- SocketAddress address, boolean tls, boolean testca) {
- InetSocketAddress addr = (InetSocketAddress) address;
- OkHttpChannelBuilder builder =
- OkHttpChannelBuilder.forAddress(addr.getHostName(), addr.getPort());
- if (!tls) {
- builder.usePlaintext();
- } else if (testca) {
- try {
- builder.sslSocketFactory(TestUtils.newSslSocketFactoryForCa(
- Platform.get().getProvider(),
- TestUtils.loadCert("ca.pem")));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ private static DomainSocketAddress parseUnixSocketAddress(String value) {
+ Preconditions.checkArgument(
+ value.startsWith(UNIX_DOMAIN_SOCKET_PREFIX),
+ "Must start with %s: %s", UNIX_DOMAIN_SOCKET_PREFIX, value);
+ // Unix Domain Socket address.
+ // Create the underlying file for the Unix Domain Socket.
+ String filePath = value.substring(UNIX_DOMAIN_SOCKET_PREFIX.length());
+ File file = new File(filePath);
+ if (!file.isAbsolute()) {
+ throw new IllegalArgumentException("File path must be absolute: " + filePath);
}
- return builder;
+ // Create the SocketAddress referencing the file.
+ return new DomainSocketAddress(file);
}
- private static NettyChannelBuilder newNettyClientChannel(Transport transport,
- SocketAddress address, boolean tls, boolean testca, int flowControlWindow)
- throws IOException {
- NettyChannelBuilder builder =
- NettyChannelBuilder.forAddress(address).flowControlWindow(flowControlWindow);
- if (!tls) {
- builder.usePlaintext();
- } else if (testca) {
- File cert = TestUtils.loadCert("ca.pem");
- builder.sslContext(GrpcSslContexts.forClient().trustManager(cert).build());
- }
-
+ private static NettyChannelBuilder configureNetty(
+ NettyChannelBuilder builder, Transport transport, int flowControlWindow) {
+ builder.flowControlWindow(flowControlWindow);
DefaultThreadFactory tf = new DefaultThreadFactory("client-elg-", true /*daemon */);
switch (transport) {
case NETTY_NIO:
@@ -194,17 +177,38 @@ public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
/**
* Create a {@link ManagedChannel} for the given parameters.
*/
- public static ManagedChannel newClientChannel(Transport transport, SocketAddress address,
+ public static ManagedChannel newClientChannel(Transport transport, String target,
boolean tls, boolean testca, @Nullable String authorityOverride,
int flowControlWindow, boolean directExecutor) {
+ ChannelCredentials credentials;
+ if (tls) {
+ if (testca) {
+ try {
+ credentials = TlsChannelCredentials.newBuilder()
+ .trustManager(TlsTesting.loadCert("ca.pem"))
+ .build();
+ } catch (IOException ex) {
+ throw new RuntimeException(ex);
+ }
+ } else {
+ credentials = TlsChannelCredentials.create();
+ }
+ } else {
+ credentials = InsecureChannelCredentials.create();
+ }
ManagedChannelBuilder builder;
if (transport == Transport.OK_HTTP) {
- builder = newOkHttpClientChannel(address, tls, testca);
+ builder = OkHttpChannelBuilder.forTarget(target, credentials)
+ .flowControlWindow(flowControlWindow);
} else {
- try {
- builder = newNettyClientChannel(transport, address, tls, testca, flowControlWindow);
- } catch (Exception e) {
- throw new RuntimeException(e);
+ if (target.startsWith(UNIX_DOMAIN_SOCKET_PREFIX)) {
+ builder = configureNetty(
+ NettyChannelBuilder.forAddress(parseUnixSocketAddress(target), credentials),
+ transport, flowControlWindow);
+ } else {
+ builder = configureNetty(
+ NettyChannelBuilder.forTarget(target, credentials),
+ transport, flowControlWindow);
}
}
if (authorityOverride != null) {
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
index c25fb38fdec..c9a5812b6a6 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
@@ -82,7 +82,7 @@ class LoadClient {
channels[i] =
Utils.newClientChannel(
Epoll.isAvailable() ? Transport.NETTY_EPOLL : Transport.NETTY_NIO,
- Utils.parseSocketAddress(config.getServerTargets(i % config.getServerTargetsCount())),
+ config.getServerTargets(i % config.getServerTargetsCount()),
config.hasSecurityParams(),
config.hasSecurityParams() && config.getSecurityParams().getUseTestCa(),
config.hasSecurityParams()
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
index f15779bdabc..3bafdb836ba 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
@@ -28,8 +28,6 @@
import io.grpc.benchmarks.proto.Messages.PayloadType;
import io.grpc.internal.testing.TestUtils;
import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
@@ -47,7 +45,7 @@ public class ClientConfiguration implements Configuration {
String authorityOverride = TestUtils.TEST_SERVER_HOST;
boolean useDefaultCiphers;
boolean directExecutor;
- SocketAddress address;
+ String target;
int channels = 4;
int outstandingRpcsPerChannel = 10;
int serverPayload;
@@ -66,7 +64,7 @@ private ClientConfiguration() {
}
public ManagedChannel newChannel() throws IOException {
- return Utils.newClientChannel(transport, address, tls, testca, authorityOverride,
+ return Utils.newClientChannel(transport, target, tls, testca, authorityOverride,
flowControlWindow, directExecutor);
}
@@ -106,18 +104,10 @@ protected ClientConfiguration build0(ClientConfiguration config) {
throw new IllegalArgumentException(
"Transport " + config.transport.name().toLowerCase() + " does not support TLS.");
}
-
- if (config.transport != Transport.OK_HTTP
- && config.testca && config.address instanceof InetSocketAddress) {
- // Override the socket address with the host from the testca.
- InetSocketAddress address = (InetSocketAddress) config.address;
- config.address = TestUtils.testServerAddress(address.getHostName(),
- address.getPort());
- }
}
// Verify that the address type is correct for the transport type.
- config.transport.validateSocketAddress(config.address);
+ config.transport.validateSocketAddress(config.target);
return config;
}
@@ -136,7 +126,7 @@ enum ClientParam implements AbstractConfigurationBuilder.Param {
+ "(unix:///path/to/file), depending on the transport selected.", null, true) {
@Override
protected void setClientValue(ClientConfiguration config, String value) {
- config.address = Utils.parseSocketAddress(value);
+ config.target = value;
}
},
CHANNELS("INT", "Number of Channels.", "" + DEFAULT.channels) {
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
index a8a097303f1..915c1da75eb 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
@@ -142,7 +142,7 @@ enum ServerParam implements AbstractConfigurationBuilder.Param {
+ "(unix:///path/to/file), depending on the transport selected.", null, true) {
@Override
protected void setServerValue(ServerConfiguration config, String value) {
- SocketAddress address = Utils.parseSocketAddress(value);
+ SocketAddress address = Utils.parseServerSocketAddress(value);
if (address instanceof InetSocketAddress) {
InetSocketAddress addr = (InetSocketAddress) address;
int port = addr.getPort() == 0 ? Utils.pickUnusedPort() : addr.getPort();
diff --git a/binder/build.gradle b/binder/build.gradle
index fa9d0d8cee9..dc3da4c9a72 100644
--- a/binder/build.gradle
+++ b/binder/build.gradle
@@ -111,12 +111,12 @@ task javadocs(type: Javadoc) {
}
task javadocJar(type: Jar, dependsOn: javadocs) {
- classifier = 'javadoc'
+ archiveClassifier = 'javadoc'
from javadocs.destinationDir
}
task sourcesJar(type: Jar) {
- classifier = 'sources'
+ archiveClassifier = 'sources'
from android.sourceSets.main.java.srcDirs
}
diff --git a/binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java b/binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java
index c37ba457b2b..4809a2db43f 100644
--- a/binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java
+++ b/binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java
@@ -69,11 +69,15 @@ public static AndroidComponentAddress forLocalComponent(Context context, Class> ongoingCalls;
+ @GuardedBy("this")
+ private final LinkedHashSet callIdsToNotifyWhenReady = new LinkedHashSet<>();
+
@GuardedBy("this")
protected Attributes attributes;
@@ -529,9 +534,18 @@ final void handleAcknowledgedBytes(long numBytes) {
logger.log(
Level.FINE,
"handleAcknowledgedBytes: Transmit Window No-Longer Full. Unblock calls: " + this);
- // We're ready again, and need to poke any waiting transactions.
- for (Inbound inbound : ongoingCalls.values()) {
- inbound.onTransportReady();
+
+ // The LinkedHashSet contract guarantees that an id already present in this collection will
+ // not lose its priority if we re-insert it here.
+ callIdsToNotifyWhenReady.addAll(ongoingCalls.keySet());
+
+ Iterator i = callIdsToNotifyWhenReady.iterator();
+ while (isReady() && i.hasNext()) {
+ Inbound inbound = ongoingCalls.get(i.next());
+ i.remove();
+ if (inbound != null) { // Calls can be removed out from under us.
+ inbound.onTransportReady();
+ }
}
}
}
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 f28b9bfb29a..da1a2961546 100644
--- a/binder/src/main/java/io/grpc/binder/internal/Inbound.java
+++ b/binder/src/main/java/io/grpc/binder/internal/Inbound.java
@@ -345,8 +345,8 @@ final synchronized void handleTransaction(Parcel parcel) {
int index = parcel.readInt();
boolean hasPrefix = TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_PREFIX);
boolean hasMessageData =
- (TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_MESSAGE_DATA));
- boolean hasSuffix = (TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_SUFFIX));
+ TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_MESSAGE_DATA);
+ boolean hasSuffix = TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_SUFFIX);
if (hasPrefix) {
handlePrefix(flags, parcel);
onDeliveryState(State.PREFIX_DELIVERED);
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 11480b36a33..650ead9bcdb 100644
--- a/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java
+++ b/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java
@@ -119,6 +119,7 @@ public synchronized void bind() {
state = State.BINDING;
Status bindResult = bindInternal(sourceContext, bindIntent, this, bindFlags);
if (!bindResult.isOk()) {
+ handleBindServiceFailure(sourceContext, this);
state = State.UNBOUND;
mainThreadExecutor.execute(() -> notifyUnbound(bindResult));
}
@@ -142,6 +143,19 @@ private static Status bindInternal(
}
}
+ // Over the years, the API contract for Context#bindService() has been inconsistent on the subject
+ // of error handling. But inspecting recent AOSP implementations shows that, internally,
+ // bindService() retains a reference to the ServiceConnection when it throws certain Exceptions
+ // and even when it returns false. To avoid leaks, we *always* call unbindService() in case of
+ // error and simply ignore any "Service not registered" IAE and other RuntimeExceptions.
+ private static void handleBindServiceFailure(Context context, ServiceConnection conn) {
+ try {
+ context.unbindService(conn);
+ } catch (RuntimeException e) {
+ logger.log(Level.FINE, "Could not clean up after bindService() failure.", e);
+ }
+ }
+
@Override
@AnyThread
public void unbind() {
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 44a3898e532..967e91b820d 100644
--- a/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java
+++ b/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java
@@ -68,6 +68,9 @@ public void setUp() {
shadowApplication = shadowOf(appContext);
shadowApplication.setComponentNameAndServiceForBindService(serviceComponent, mockBinder);
+ // Don't call onServiceDisconnected() upon unbindService(), just like the real Android doesn't.
+ shadowApplication.setUnbindServiceCallsOnServiceDisconnected(false);
+
binding = newBuilder().build();
shadowOf(getMainLooper()).idle();
}
@@ -137,6 +140,7 @@ public void testBindUnbind() throws Exception {
assertThat(observer.gotUnboundEvent).isTrue();
assertThat(observer.unboundReason.getCode()).isEqualTo(Code.CANCELLED);
assertThat(binding.isSourceContextCleared()).isTrue();
+ assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
}
@Test
@@ -174,6 +178,7 @@ public void testBindFailure() throws Exception {
assertThat(observer.gotUnboundEvent).isTrue();
assertThat(observer.unboundReason.getCode()).isEqualTo(Code.UNIMPLEMENTED);
assertThat(binding.isSourceContextCleared()).isTrue();
+ assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
}
@Test
@@ -187,6 +192,7 @@ public void testBindSecurityException() throws Exception {
assertThat(observer.unboundReason.getCode()).isEqualTo(Code.PERMISSION_DENIED);
assertThat(observer.unboundReason.getCause()).isEqualTo(securityException);
assertThat(binding.isSourceContextCleared()).isTrue();
+ assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
}
@Test
@@ -257,7 +263,8 @@ private void assertNoLockHeld() {
} catch (IllegalMonitorStateException ime) {
// Expected.
} catch (InterruptedException inte) {
- throw new AssertionError("Interrupted exception when we shouldn't have been able to wait.", inte);
+ throw new AssertionError(
+ "Interrupted exception when we shouldn't have been able to wait.", inte);
}
}
diff --git a/bom/build.gradle b/bom/build.gradle
index 49fcb3cbd90..be2722d4bc0 100644
--- a/bom/build.gradle
+++ b/bom/build.gradle
@@ -14,7 +14,7 @@ publishing {
// Generate bom using subprojects
def internalProjects = [
project.name,
- 'grpc-binder',
+ 'grpc-authz',
'grpc-compiler',
'grpc-gae-interop-testing-jdk8',
]
diff --git a/build.gradle b/build.gradle
index 149ade4ae02..51dbffae770 100644
--- a/build.gradle
+++ b/build.gradle
@@ -19,7 +19,7 @@ subprojects {
apply plugin: "net.ltgt.errorprone"
group = "io.grpc"
- version = "1.44.0-SNAPSHOT" // CURRENT_GRPC_VERSION
+ version = "1.45.0" // CURRENT_GRPC_VERSION
repositories {
maven { // The google mirror is less flaky than mavenCentral()
@@ -56,12 +56,12 @@ subprojects {
javaPluginPath = "$rootDir/compiler/build/exe/java_plugin/$protocPluginBaseName$exeSuffix"
nettyVersion = '4.1.72.Final'
- guavaVersion = '30.1.1-android'
- googleauthVersion = '0.22.2'
+ guavaVersion = '31.0.1-android'
+ googleauthVersion = '1.4.0'
protobufVersion = '3.19.2'
protocVersion = protobufVersion
opencensusVersion = '0.28.0'
- autovalueVersion = '1.7.4'
+ autovalueVersion = '1.9'
configureProtoCompilation = {
String generatedSourcePath = "${projectDir}/src/generated"
@@ -151,7 +151,7 @@ subprojects {
animalsniffer_annotations: "org.codehaus.mojo:animal-sniffer-annotations:1.19",
autovalue: "com.google.auto.value:auto-value:${autovalueVersion}",
autovalue_annotation: "com.google.auto.value:auto-value-annotations:${autovalueVersion}",
- errorprone: "com.google.errorprone:error_prone_annotations:2.9.0",
+ errorprone: "com.google.errorprone:error_prone_annotations:2.10.0",
cronet_api: 'org.chromium.net:cronet-api:92.4515.131',
cronet_embedded: 'org.chromium.net:cronet-embedded:92.4515.131',
gson: "com.google.code.gson:gson:2.8.9",
@@ -176,6 +176,7 @@ subprojects {
netty: "io.netty:netty-codec-http2:[${nettyVersion}]",
netty_epoll: "io.netty:netty-transport-native-epoll:${nettyVersion}:linux-x86_64",
+ netty_epoll_arm64: "io.netty:netty-transport-native-epoll:${nettyVersion}:linux-aarch_64",
netty_proxy_handler: "io.netty:netty-handler-proxy:${nettyVersion}",
// Keep the following references of tcnative version in sync whenever it's updated
@@ -239,25 +240,21 @@ subprojects {
}
}
- if (rootProject.properties.get('errorProne', true)) {
+ if (!project.hasProperty('errorProne') || errorProne.toBoolean()) {
dependencies {
- errorprone 'com.google.errorprone:error_prone_core:2.4.0'
+ errorprone 'com.google.errorprone:error_prone_core:2.10.0'
errorproneJavac 'com.google.errorprone:javac:9+181-r4173-1'
}
} else {
// Disable Error Prone
- allprojects {
- afterEvaluate { project ->
- project.tasks.withType(JavaCompile) {
- options.errorprone.enabled = false
- }
- }
+ tasks.withType(JavaCompile) {
+ options.errorprone.enabled = false
}
}
plugins.withId("java") {
- sourceCompatibility = 1.7
- targetCompatibility = 1.7
+ sourceCompatibility = 1.8
+ targetCompatibility = 1.8
dependencies {
testImplementation libraries.junit,
@@ -304,7 +301,7 @@ subprojects {
maxHeapSize = '1500m'
}
- if (rootProject.properties.get('errorProne', true)) {
+ if (!project.hasProperty('errorProne') || errorProne.toBoolean()) {
dependencies {
annotationProcessor 'com.google.guava:guava-beta-checker:1.0'
}
@@ -315,6 +312,7 @@ subprojects {
options.errorprone.check("UnnecessaryAnonymousClass", CheckSeverity.OFF)
// This project targets Java 7 (no time.Duration class)
options.errorprone.check("PreferJavaTimeOverload", CheckSeverity.OFF)
+ options.errorprone.check("JavaUtilDate", CheckSeverity.OFF)
// The warning fails to provide a source location
options.errorprone.check("MissingSummary", CheckSeverity.OFF)
}
@@ -323,6 +321,7 @@ subprojects {
options.errorprone.check("JdkObsolete", CheckSeverity.OFF)
options.errorprone.check("UnnecessaryAnonymousClass", CheckSeverity.OFF)
options.errorprone.check("PreferJavaTimeOverload", CheckSeverity.OFF)
+ options.errorprone.check("JavaUtilDate", CheckSeverity.OFF)
}
plugins.withId("ru.vyarus.animalsniffer") {
diff --git a/buildscripts/kokoro/kokoro.sh b/buildscripts/kokoro/kokoro.sh
new file mode 100755
index 00000000000..0b3864b5092
--- /dev/null
+++ b/buildscripts/kokoro/kokoro.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+spongify_logs() {
+ local f
+ while read -r f; do
+ mkdir "${f%.xml}"
+ cp "$f" "${f%.xml}/sponge_log.xml"
+ done < <(find "${KOKORO_ARTIFACTS_DIR:-.}" -name 'TEST-*.xml')
+}
diff --git a/buildscripts/kokoro/linux_aarch64.cfg b/buildscripts/kokoro/linux_aarch64.cfg
index f91fbe4d702..325d910c5ea 100644
--- a/buildscripts/kokoro/linux_aarch64.cfg
+++ b/buildscripts/kokoro/linux_aarch64.cfg
@@ -6,7 +6,8 @@ timeout_mins: 60
action {
define_artifacts {
+ regex: "github/grpc-java/**/build/test-results/**/sponge_log.xml"
regex: "github/grpc-java/mvn-artifacts/**"
regex: "github/grpc-java/artifacts/**"
}
-}
\ No newline at end of file
+}
diff --git a/buildscripts/kokoro/linux_aarch64.sh b/buildscripts/kokoro/linux_aarch64.sh
index 11c3f8ae3a1..f4a1292efb5 100755
--- a/buildscripts/kokoro/linux_aarch64.sh
+++ b/buildscripts/kokoro/linux_aarch64.sh
@@ -5,6 +5,11 @@ if [[ -f /VERSION ]]; then
cat /VERSION
fi
+readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+
+. "$GRPC_JAVA_DIR"/buildscripts/kokoro/kokoro.sh
+trap spongify_logs EXIT
+
cd github/grpc-java
buildscripts/qemu_helpers/prepare_qemu.sh
diff --git a/buildscripts/kokoro/linux_artifacts.cfg b/buildscripts/kokoro/linux_artifacts.cfg
index 0938e4bff2e..8691b5ff356 100644
--- a/buildscripts/kokoro/linux_artifacts.cfg
+++ b/buildscripts/kokoro/linux_artifacts.cfg
@@ -6,6 +6,7 @@ timeout_mins: 60
action {
define_artifacts {
+ regex: "github/grpc-java/**/build/test-results/**/sponge_log.xml"
regex: "github/grpc-java/mvn-artifacts/**"
regex: "github/grpc-java/artifacts/**"
}
diff --git a/buildscripts/kokoro/linux_artifacts.sh b/buildscripts/kokoro/linux_artifacts.sh
index b4551843c6a..e23b2bcc628 100755
--- a/buildscripts/kokoro/linux_artifacts.sh
+++ b/buildscripts/kokoro/linux_artifacts.sh
@@ -7,6 +7,9 @@ fi
readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+. "$GRPC_JAVA_DIR"/buildscripts/kokoro/kokoro.sh
+trap spongify_logs EXIT
+
"$GRPC_JAVA_DIR"/buildscripts/build_docker.sh
"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh /grpc-java/buildscripts/build_artifacts_in_docker.sh
diff --git a/buildscripts/kokoro/macos.cfg b/buildscripts/kokoro/macos.cfg
index a6bf290d1ec..f79634e3cf8 100644
--- a/buildscripts/kokoro/macos.cfg
+++ b/buildscripts/kokoro/macos.cfg
@@ -1,7 +1,7 @@
# Config file for internal CI
# Location of the continuous shell script in repository.
-build_file: "grpc-java/buildscripts/kokoro/unix.sh"
+build_file: "grpc-java/buildscripts/kokoro/macos.sh"
timeout_mins: 45
# We had problems with random tests timing out because it took seconds to do
@@ -15,7 +15,7 @@ env_vars {
# We always build mvn artifacts.
action {
define_artifacts {
- regex: "github/grpc-java/**/build/reports/**"
+ regex: "github/grpc-java/**/build/test-results/**/sponge_log.xml"
regex: "github/grpc-java/mvn-artifacts/**"
}
}
diff --git a/buildscripts/kokoro/macos.sh b/buildscripts/kokoro/macos.sh
new file mode 100755
index 00000000000..df52a004f52
--- /dev/null
+++ b/buildscripts/kokoro/macos.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -veux -o pipefail
+
+if [[ -f /VERSION ]]; then
+ cat /VERSION
+fi
+
+readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+
+. "$GRPC_JAVA_DIR"/buildscripts/kokoro/kokoro.sh
+trap spongify_logs EXIT
+
+"$GRPC_JAVA_DIR"/buildscripts/kokoro/unix.sh
diff --git a/buildscripts/kokoro/unix.sh b/buildscripts/kokoro/unix.sh
index 61d65324a07..91ee67f1d98 100755
--- a/buildscripts/kokoro/unix.sh
+++ b/buildscripts/kokoro/unix.sh
@@ -16,10 +16,6 @@ set -exu -o pipefail
# It would be nicer to use 'readlink -f' here but osx does not support it.
readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
-if [[ -f /VERSION ]]; then
- cat /VERSION
-fi
-
# cd to the root dir of grpc-java
cd $(dirname $0)/../..
@@ -48,7 +44,7 @@ export LD_LIBRARY_PATH=/tmp/protobuf/lib
export LDFLAGS=-L/tmp/protobuf/lib
export CXXFLAGS="-I/tmp/protobuf/include"
-./gradlew clean $GRADLE_FLAGS
+./gradlew grpc-compiler:clean $GRADLE_FLAGS
if [[ -z "${SKIP_TESTS:-}" ]]; then
# Ensure all *.proto changes include *.java generated code
@@ -62,7 +58,6 @@ if [[ -z "${SKIP_TESTS:-}" ]]; then
# Run tests
./gradlew build :grpc-all:jacocoTestReport $GRADLE_FLAGS
pushd examples
- ./gradlew clean $GRADLE_FLAGS
./gradlew build $GRADLE_FLAGS
# --batch-mode reduces log spam
mvn verify --batch-mode
diff --git a/buildscripts/kokoro/windows.cfg b/buildscripts/kokoro/windows.cfg
index 6b2703f99c9..bdfaa38904f 100644
--- a/buildscripts/kokoro/windows.cfg
+++ b/buildscripts/kokoro/windows.cfg
@@ -7,7 +7,7 @@ timeout_mins: 45
# We always build mvn artifacts.
action {
define_artifacts {
- regex: "**/build/test-results/**/*.xml"
+ regex: "github/grpc-java/**/build/test-results/**/sponge_log.xml"
regex: "github/grpc-java/mvn-artifacts/**"
}
}
diff --git a/buildscripts/kokoro/windows64.bat b/buildscripts/kokoro/windows64.bat
index edcb421fe7d..eaa1fcf845e 100644
--- a/buildscripts/kokoro/windows64.bat
+++ b/buildscripts/kokoro/windows64.bat
@@ -32,4 +32,4 @@ SET GRADLE_FLAGS=-PtargetArch=%TARGET_ARCH% -PfailOnWarnings=%FAIL_ON_WARNINGS%
@rem make sure no daemons have any files open
cmd.exe /C "%WORKSPACE%\gradlew.bat --stop"
-cmd.exe /C "%WORKSPACE%\gradlew.bat %GRADLE_FLAGS% -Dorg.gradle.parallel=false -PrepositoryDir=%WORKSPACE%\artifacts clean grpc-compiler:build grpc-compiler:publish" || exit /b 1
+cmd.exe /C "%WORKSPACE%\gradlew.bat %GRADLE_FLAGS% -Dorg.gradle.parallel=false -PrepositoryDir=%WORKSPACE%\artifacts grpc-compiler:clean grpc-compiler:build grpc-compiler:publish" || exit /b 1
diff --git a/buildscripts/kokoro/xds_k8s_lb.cfg b/buildscripts/kokoro/xds_k8s_lb.cfg
new file mode 100644
index 00000000000..43971896cd4
--- /dev/null
+++ b/buildscripts/kokoro/xds_k8s_lb.cfg
@@ -0,0 +1,13 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/xds_k8s_lb.sh"
+timeout_mins: 180
+
+action {
+ define_artifacts {
+ regex: "artifacts/**/*sponge_log.xml"
+ regex: "artifacts/**/*sponge_log.log"
+ strip_prefix: "artifacts"
+ }
+}
diff --git a/buildscripts/kokoro/xds_k8s_lb.sh b/buildscripts/kokoro/xds_k8s_lb.sh
new file mode 100755
index 00000000000..22f1e383440
--- /dev/null
+++ b/buildscripts/kokoro/xds_k8s_lb.sh
@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# Constants
+readonly GITHUB_REPOSITORY_NAME="grpc-java"
+readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/grpc/${TEST_DRIVER_BRANCH:-master}/tools/internal_ci/linux/grpc_xds_k8s_install_test_driver.sh"
+## xDS test server/client Docker images
+readonly SERVER_IMAGE_NAME="gcr.io/grpc-testing/xds-interop/java-server"
+readonly CLIENT_IMAGE_NAME="gcr.io/grpc-testing/xds-interop/java-client"
+readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}"
+readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing"
+
+#######################################
+# Builds the test app using gradle and smoke-checks its binaries
+# Globals:
+# SRC_DIR
+# BUILD_APP_PATH
+# Arguments:
+# None
+# Outputs:
+# Writes the output of xds-test-client and xds-test-server --help to stderr
+#######################################
+build_java_test_app() {
+ echo "Building Java test app"
+ cd "${SRC_DIR}"
+ ./gradlew --no-daemon grpc-interop-testing:installDist -x test \
+ -PskipCodegen=true -PskipAndroid=true --console=plain
+
+ # Test-run binaries
+ run_ignore_exit_code "${SRC_DIR}/${BUILD_APP_PATH}/bin/xds-test-client" --help
+ run_ignore_exit_code "${SRC_DIR}/${BUILD_APP_PATH}/bin/xds-test-server" --help
+}
+
+#######################################
+# Builds test app Docker images and pushes them to GCR
+# Globals:
+# BUILD_APP_PATH
+# SERVER_IMAGE_NAME: Test server Docker image name
+# CLIENT_IMAGE_NAME: Test client Docker image name
+# GIT_COMMIT: SHA-1 of git commit being built
+# Arguments:
+# None
+# Outputs:
+# Writes the output of `gcloud builds submit` to stdout, stderr
+#######################################
+build_test_app_docker_images() {
+ echo "Building Java xDS interop test app Docker images"
+ local docker_dir="${SRC_DIR}/buildscripts/xds-k8s"
+ local build_dir
+ build_dir="$(mktemp -d)"
+ # Copy Docker files, log properties, and the test app to the build dir
+ cp -v "${docker_dir}/"*.Dockerfile "${build_dir}"
+ cp -v "${docker_dir}/"*.properties "${build_dir}"
+ cp -rv "${SRC_DIR}/${BUILD_APP_PATH}" "${build_dir}"
+ # Pick a branch name for the built image
+ if [[ -n $KOKORO_JOB_NAME ]]; then
+ branch_name=$(echo "$KOKORO_JOB_NAME" | sed -E 's|^grpc/java/([^/]+)/.*|\1|')
+ else
+ branch_name='experimental'
+ fi
+ # Run Google Cloud Build
+ gcloud builds submit "${build_dir}" \
+ --config "${docker_dir}/cloudbuild.yaml" \
+ --substitutions "_SERVER_IMAGE_NAME=${SERVER_IMAGE_NAME},_CLIENT_IMAGE_NAME=${CLIENT_IMAGE_NAME},COMMIT_SHA=${GIT_COMMIT},BRANCH_NAME=${branch_name}"
+ # TODO(sergiitk): extra "cosmetic" tags for versioned branches, e.g. v1.34.x
+ # TODO(sergiitk): do this when adding support for custom configs per version
+}
+
+#######################################
+# Builds test app and its docker images unless they already exist
+# Globals:
+# SERVER_IMAGE_NAME: Test server Docker image name
+# CLIENT_IMAGE_NAME: Test client Docker image name
+# GIT_COMMIT: SHA-1 of git commit being built
+# FORCE_IMAGE_BUILD
+# Arguments:
+# None
+# Outputs:
+# Writes the output to stdout, stderr
+#######################################
+build_docker_images_if_needed() {
+ # Check if images already exist
+ server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")"
+ printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}"
+ echo "${server_tags:-Server image not found}"
+
+ client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")"
+ printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}"
+ echo "${client_tags:-Client image not found}"
+
+ # Build if any of the images are missing, or FORCE_IMAGE_BUILD=1
+ if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then
+ build_java_test_app
+ build_test_app_docker_images
+ else
+ echo "Skipping Java test app build"
+ fi
+}
+
+#######################################
+# Executes the test case
+# Globals:
+# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile
+# KUBE_CONTEXT: The name of kubectl context with GKE cluster access
+# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report
+# SERVER_IMAGE_NAME: Test server Docker image name
+# CLIENT_IMAGE_NAME: Test client Docker image name
+# GIT_COMMIT: SHA-1 of git commit being built
+# Arguments:
+# Test case name
+# Outputs:
+# Writes the output of test execution to stdout, stderr
+# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml
+#######################################
+run_test() {
+ # Test driver usage:
+ # https://github.com/grpc/grpc/tree/master/tools/run_tests/xds_k8s_test_driver#basic-usage
+ local test_name="${1:?Usage: run_test test_name}"
+ set -x
+ python -m "tests.${test_name}" \
+ --flagfile="${TEST_DRIVER_FLAGFILE}" \
+ --kube_context="${KUBE_CONTEXT}" \
+ --server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \
+ --client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \
+ --xml_output_file="${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml" \
+ --force_cleanup
+ set +x
+}
+
+#######################################
+# Main function: provision software necessary to execute tests, and run them
+# Globals:
+# KOKORO_ARTIFACTS_DIR
+# GITHUB_REPOSITORY_NAME
+# SRC_DIR: Populated with absolute path to the source repo
+# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing
+# the test driver
+# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code
+# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile
+# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report
+# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build
+# GIT_COMMIT: Populated with the SHA-1 of git commit being built
+# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built
+# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access
+# Arguments:
+# None
+# Outputs:
+# Writes the output of test execution to stdout, stderr
+#######################################
+main() {
+ local script_dir
+ script_dir="$(dirname "$0")"
+
+ # Source the test driver from the master branch.
+ echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}"
+ source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")"
+
+ activate_gke_cluster GKE_CLUSTER_PSM_BASIC
+
+ set -x
+ if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then
+ kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}"
+ else
+ local_setup_test_driver "${script_dir}"
+ fi
+ build_docker_images_if_needed
+ # Run tests
+ cd "${TEST_DRIVER_FULL_DIR}"
+ run_test api_listener_test
+}
+
+main "$@"
diff --git a/compiler/src/test/golden/TestDeprecatedService.java.txt b/compiler/src/test/golden/TestDeprecatedService.java.txt
index 68d8e1172a3..eda5a4de6ab 100644
--- a/compiler/src/test/golden/TestDeprecatedService.java.txt
+++ b/compiler/src/test/golden/TestDeprecatedService.java.txt
@@ -8,7 +8,7 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
*
*/
@javax.annotation.Generated(
- value = "by gRPC proto compiler (version 1.44.0-SNAPSHOT)",
+ value = "by gRPC proto compiler (version 1.45.0)",
comments = "Source: grpc/testing/compiler/test.proto")
@io.grpc.stub.annotations.GrpcGenerated
@java.lang.Deprecated
diff --git a/compiler/src/test/golden/TestService.java.txt b/compiler/src/test/golden/TestService.java.txt
index 3c6cdc82b51..6bb5aaebfc9 100644
--- a/compiler/src/test/golden/TestService.java.txt
+++ b/compiler/src/test/golden/TestService.java.txt
@@ -8,7 +8,7 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
*
*/
@javax.annotation.Generated(
- value = "by gRPC proto compiler (version 1.44.0-SNAPSHOT)",
+ value = "by gRPC proto compiler (version 1.45.0)",
comments = "Source: grpc/testing/compiler/test.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class TestServiceGrpc {
diff --git a/compiler/src/testLite/golden/TestDeprecatedService.java.txt b/compiler/src/testLite/golden/TestDeprecatedService.java.txt
index 8dcafe51f24..ab35321fe87 100644
--- a/compiler/src/testLite/golden/TestDeprecatedService.java.txt
+++ b/compiler/src/testLite/golden/TestDeprecatedService.java.txt
@@ -8,7 +8,7 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
*
*/
@javax.annotation.Generated(
- value = "by gRPC proto compiler (version 1.44.0-SNAPSHOT)",
+ value = "by gRPC proto compiler (version 1.45.0)",
comments = "Source: grpc/testing/compiler/test.proto")
@io.grpc.stub.annotations.GrpcGenerated
@java.lang.Deprecated
diff --git a/compiler/src/testLite/golden/TestService.java.txt b/compiler/src/testLite/golden/TestService.java.txt
index 60ac085f920..e72fa752e52 100644
--- a/compiler/src/testLite/golden/TestService.java.txt
+++ b/compiler/src/testLite/golden/TestService.java.txt
@@ -8,7 +8,7 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
*
*/
@javax.annotation.Generated(
- value = "by gRPC proto compiler (version 1.44.0-SNAPSHOT)",
+ value = "by gRPC proto compiler (version 1.45.0)",
comments = "Source: grpc/testing/compiler/test.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class TestServiceGrpc {
diff --git a/context/build.gradle b/context/build.gradle
index 35ad0566bb6..5815374aeb3 100644
--- a/context/build.gradle
+++ b/context/build.gradle
@@ -9,11 +9,17 @@ plugins {
description = 'gRPC: Context'
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
+
dependencies {
testImplementation libraries.jsr305
- testImplementation (libraries.guava_testlib) {
+ // Explicitly choose the guava version to stay Java 7-compatible. The rest of gRPC can move
+ // forward to Java 8-requiring versions. This is also only used for testing, so is unlikely to
+ // cause problems.
+ testImplementation ('com.google.guava:guava-testlib:30.1.1-android') {
exclude group: 'junit', module: 'junit'
}
signature "org.codehaus.mojo.signature:java17:1.0@signature"
- signature "net.sf.androidscents.signature:android-api-level-19:4.4.2_r4@signature"
+ signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
}
diff --git a/context/src/main/java/io/grpc/Context.java b/context/src/main/java/io/grpc/Context.java
index ad47ca9cb4d..41d3a5c94a6 100644
--- a/context/src/main/java/io/grpc/Context.java
+++ b/context/src/main/java/io/grpc/Context.java
@@ -1042,7 +1042,7 @@ public Context doAttach(Context toAttach) {
* Implements {@link io.grpc.Context#current}.
*
* Caution: {@link Context} interprets a return value of {@code null} to mean the same
- * thing as {@code Context{@link #ROOT}}.
+ * thing as {@link Context#ROOT}.
*
*
See also {@link #doAttach(Context)}.
*
diff --git a/core/build.gradle b/core/build.gradle
index ed8e5400765..bc8231fd9e1 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -43,7 +43,7 @@ dependencies {
jmh project(':grpc-testing')
signature "org.codehaus.mojo.signature:java17:1.0@signature"
- signature "net.sf.androidscents.signature:android-api-level-19:4.4.2_r4@signature"
+ signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
}
javadoc {
diff --git a/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java b/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java
index d20c60cd446..c1268cfdb09 100644
--- a/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java
+++ b/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java
@@ -17,6 +17,7 @@
package io.grpc.internal;
import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.DoNotCall;
import io.grpc.BinaryLog;
import io.grpc.BindableService;
import io.grpc.CompressorRegistry;
@@ -53,6 +54,7 @@ protected AbstractServerImplBuilder() {}
/**
* This method serves to force sub classes to "hide" this static factory.
*/
+ @DoNotCall("Unsupported")
public static ServerBuilder forPort(int port) {
throw new UnsupportedOperationException("Subclass failed to hide static factory");
}
diff --git a/core/src/main/java/io/grpc/internal/ClientCallImpl.java b/core/src/main/java/io/grpc/internal/ClientCallImpl.java
index e60f9e54b47..db1a992b968 100644
--- a/core/src/main/java/io/grpc/internal/ClientCallImpl.java
+++ b/core/src/main/java/io/grpc/internal/ClientCallImpl.java
@@ -53,7 +53,7 @@
import io.perfmark.PerfMark;
import io.perfmark.Tag;
import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.Locale;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
@@ -71,7 +71,7 @@ final class ClientCallImpl extends ClientCall {
private static final Logger log = Logger.getLogger(ClientCallImpl.class.getName());
private static final byte[] FULL_STREAM_DECOMPRESSION_ENCODINGS
- = "gzip".getBytes(StandardCharsets.US_ASCII);
+ = "gzip".getBytes(Charset.forName("US-ASCII"));
private final MethodDescriptor method;
private final Tag tag;
diff --git a/core/src/main/java/io/grpc/internal/ClientStreamListener.java b/core/src/main/java/io/grpc/internal/ClientStreamListener.java
index dfb521f40a3..8db1fbe445f 100644
--- a/core/src/main/java/io/grpc/internal/ClientStreamListener.java
+++ b/core/src/main/java/io/grpc/internal/ClientStreamListener.java
@@ -57,12 +57,16 @@ enum RpcProgress {
*/
PROCESSED,
/**
- * The RPC is not processed by the server's application logic.
+ * The stream on the wire is created but not processed by the server's application logic.
*/
REFUSED,
/**
* The RPC is dropped (by load balancer).
*/
- DROPPED
+ DROPPED,
+ /**
+ * The stream is closed even before anything leaves the client.
+ */
+ MISCARRIED
}
}
diff --git a/core/src/main/java/io/grpc/internal/GrpcUtil.java b/core/src/main/java/io/grpc/internal/GrpcUtil.java
index bce1a0f1503..6762c7853fb 100644
--- a/core/src/main/java/io/grpc/internal/GrpcUtil.java
+++ b/core/src/main/java/io/grpc/internal/GrpcUtil.java
@@ -55,7 +55,6 @@
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Executor;
@@ -76,7 +75,7 @@ public final class GrpcUtil {
private static final Logger log = Logger.getLogger(GrpcUtil.class.getName());
- public static final Charset US_ASCII = StandardCharsets.US_ASCII;
+ public static final Charset US_ASCII = Charset.forName("US-ASCII");
/**
* {@link io.grpc.Metadata.Key} for the timeout header.
@@ -204,7 +203,7 @@ public byte[] parseAsciiString(byte[] serialized) {
public static final Splitter ACCEPT_ENCODING_SPLITTER = Splitter.on(',').trimResults();
- private static final String IMPLEMENTATION_VERSION = "1.44.0-SNAPSHOT"; // CURRENT_GRPC_VERSION
+ private static final String IMPLEMENTATION_VERSION = "1.45.0"; // CURRENT_GRPC_VERSION
/**
* The default timeout in nanos for a keepalive ping request.
diff --git a/core/src/main/java/io/grpc/internal/InternalSubchannel.java b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
index fa2bf2e46bc..4f7c8d1f22f 100644
--- a/core/src/main/java/io/grpc/internal/InternalSubchannel.java
+++ b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
@@ -772,6 +772,9 @@ private String printShortStatus(Status status) {
if (status.getDescription() != null) {
buffer.append("(").append(status.getDescription()).append(")");
}
+ if (status.getCause() != null) {
+ buffer.append("[").append(status.getCause()).append("]");
+ }
return buffer.toString();
}
diff --git a/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java b/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
index a13c9fe4665..22e08de9cf4 100644
--- a/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
+++ b/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
@@ -140,7 +140,7 @@ public List resolveSrv(String host) throws Exception {
Level level = Level.WARNING;
for (String rawSrv : rawSrvRecords) {
try {
- String[] parts = whitespace.split(rawSrv);
+ String[] parts = whitespace.split(rawSrv, 5);
Verify.verify(parts.length == 4, "Bad SRV Record: %s", rawSrv);
// SRV requires the host name to be absolute
if (!parts[3].endsWith(".")) {
diff --git a/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java b/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
index 0cc1dd3aaca..3e7dd010e22 100644
--- a/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
+++ b/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
@@ -202,7 +202,14 @@ public ProxiedSocketAddress proxyFor(SocketAddress targetServerAddress) throws I
private ProxiedSocketAddress detectProxy(InetSocketAddress targetAddr) throws IOException {
URI uri;
- String host = GrpcUtil.getHost(targetAddr);
+ String host;
+ try {
+ host = GrpcUtil.getHost(targetAddr);
+ } catch (Throwable t) {
+ // Workaround for Android API levels < 19 if getHostName causes a NetworkOnMainThreadException
+ log.log(Level.WARNING, "Failed to get host for proxy lookup, proceeding without proxy", t);
+ return null;
+ }
try {
uri =
new URI(
diff --git a/core/src/main/java/io/grpc/internal/RetriableStream.java b/core/src/main/java/io/grpc/internal/RetriableStream.java
index 4afdb3f750e..d0430b5edbd 100644
--- a/core/src/main/java/io/grpc/internal/RetriableStream.java
+++ b/core/src/main/java/io/grpc/internal/RetriableStream.java
@@ -101,9 +101,12 @@ public void uncaughtException(Thread t, Throwable e) {
false, 0);
/**
- * Either transparent retry happened or reached server's application logic.
+ * Either non-local transparent retry happened or reached server's application logic.
+ *
+ * Note that local-only transparent retries are unlimited.
*/
private final AtomicBoolean noMoreTransparentRetry = new AtomicBoolean();
+ private final AtomicInteger localOnlyTransparentRetries = new AtomicInteger();
// Used for recording the share of buffer used for the current call out of the channel buffer.
// This field would not be necessary if there is no channel buffer limit.
@@ -849,10 +852,29 @@ public void run() {
}
return;
}
+ if (rpcProgress == RpcProgress.MISCARRIED
+ && localOnlyTransparentRetries.incrementAndGet() > 10_000) {
+ commitAndRun(substream);
+ if (state.winningSubstream == substream) {
+ Status tooManyTransparentRetries = Status.INTERNAL
+ .withDescription("Too many transparent retries. Might be a bug in gRPC")
+ .withCause(status.asRuntimeException());
+ listenerSerializeExecutor.execute(
+ new Runnable() {
+ @Override
+ public void run() {
+ isClosed = true;
+ masterListener.closed(tooManyTransparentRetries, rpcProgress, trailers);
+ }
+ });
+ }
+ return;
+ }
if (state.winningSubstream == null) {
- if (rpcProgress == RpcProgress.REFUSED
- && noMoreTransparentRetry.compareAndSet(false, true)) {
+ if (rpcProgress == RpcProgress.MISCARRIED
+ || (rpcProgress == RpcProgress.REFUSED
+ && noMoreTransparentRetry.compareAndSet(false, true))) {
// transparent retry
final Substream newSubstream = createSubstream(substream.previousAttemptCount, true);
if (isHedging) {
diff --git a/core/src/main/java/io/grpc/internal/SubchannelChannel.java b/core/src/main/java/io/grpc/internal/SubchannelChannel.java
index a1d454ed2fb..773dcb99dd7 100644
--- a/core/src/main/java/io/grpc/internal/SubchannelChannel.java
+++ b/core/src/main/java/io/grpc/internal/SubchannelChannel.java
@@ -43,7 +43,7 @@ final class SubchannelChannel extends Channel {
Status.UNAVAILABLE.withDescription(
"wait-for-ready RPC is not supported on Subchannel.asChannel()");
private static final FailingClientTransport notReadyTransport =
- new FailingClientTransport(NOT_READY_ERROR, RpcProgress.REFUSED);
+ new FailingClientTransport(NOT_READY_ERROR, RpcProgress.MISCARRIED);
private final InternalSubchannel subchannel;
private final Executor executor;
private final ScheduledExecutorService deadlineCancellationExecutor;
diff --git a/core/src/test/java/io/grpc/internal/JsonUtilTest.java b/core/src/test/java/io/grpc/internal/JsonUtilTest.java
index 960800c97c0..a01f8868220 100644
--- a/core/src/test/java/io/grpc/internal/JsonUtilTest.java
+++ b/core/src/test/java/io/grpc/internal/JsonUtilTest.java
@@ -19,6 +19,7 @@
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
@@ -130,4 +131,16 @@ public void getNumber() {
assertThat(JsonUtil.getNumberAsInteger(map, "key_nonexistent")).isNull();
assertThat(JsonUtil.getNumberAsLong(map, "key_nonexistent")).isNull();
}
+
+ @Test
+ public void getObject_mapExplicitNullValue() {
+ Map mapWithNullValue = Collections.singletonMap("key", null);
+ try {
+ JsonUtil.getObject(mapWithNullValue, "key");
+ fail("ClassCastException expected");
+ } catch (ClassCastException e) {
+ assertThat(e).hasMessageThat()
+ .isEqualTo("value 'null' for key 'key' in '{key=null}' is not object");
+ }
+ }
}
diff --git a/core/src/test/java/io/grpc/internal/RetriableStreamTest.java b/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
index 8b851573b21..025c4f23e80 100644
--- a/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
@@ -18,6 +18,7 @@
import static com.google.common.truth.Truth.assertThat;
import static io.grpc.internal.ClientStreamListener.RpcProgress.DROPPED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.MISCARRIED;
import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
import static io.grpc.internal.ClientStreamListener.RpcProgress.REFUSED;
import static io.grpc.internal.RetriableStream.GRPC_PREVIOUS_RPC_ATTEMPTS;
@@ -1611,7 +1612,7 @@ public void throttleStream_Succeed() {
}
@Test
- public void transparentRetry() {
+ public void transparentRetry_onlyOnceOnRefused() {
ClientStream mockStream1 = mock(ClientStream.class);
ClientStream mockStream2 = mock(ClientStream.class);
ClientStream mockStream3 = mock(ClientStream.class);
@@ -1661,6 +1662,72 @@ public void transparentRetry() {
assertEquals(0, fakeClock.numPendingTasks());
}
+ @Test
+ public void transparentRetry_unlimitedTimesOnMiscarried() {
+ ClientStream mockStream1 = mock(ClientStream.class);
+ ClientStream mockStream2 = mock(ClientStream.class);
+ ClientStream mockStream3 = mock(ClientStream.class);
+ InOrder inOrder = inOrder(
+ retriableStreamRecorder,
+ mockStream1, mockStream2, mockStream3);
+
+ // start
+ doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+ retriableStream.start(masterListener);
+
+ inOrder.verify(retriableStreamRecorder).newSubstream(0);
+ ArgumentCaptor sublistenerCaptor1 =
+ ArgumentCaptor.forClass(ClientStreamListener.class);
+ inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+ inOrder.verify(mockStream1).isReady();
+ inOrder.verifyNoMoreInteractions();
+
+ // transparent retry
+ doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(0);
+ sublistenerCaptor1.getValue()
+ .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), MISCARRIED, new Metadata());
+
+ inOrder.verify(retriableStreamRecorder).newSubstream(0);
+ ArgumentCaptor sublistenerCaptor2 =
+ ArgumentCaptor.forClass(ClientStreamListener.class);
+ inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+ inOrder.verify(mockStream2).isReady();
+ inOrder.verifyNoMoreInteractions();
+ verify(retriableStreamRecorder, never()).postCommit();
+ assertEquals(0, fakeClock.numPendingTasks());
+
+ // more transparent retry
+ doReturn(mockStream3).when(retriableStreamRecorder).newSubstream(0);
+ sublistenerCaptor2.getValue()
+ .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), MISCARRIED, new Metadata());
+
+ inOrder.verify(retriableStreamRecorder).newSubstream(0);
+ ArgumentCaptor sublistenerCaptor3 =
+ ArgumentCaptor.forClass(ClientStreamListener.class);
+ inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+ inOrder.verify(mockStream3).isReady();
+ inOrder.verifyNoMoreInteractions();
+ verify(retriableStreamRecorder, never()).postCommit();
+ assertEquals(0, fakeClock.numPendingTasks());
+
+ ArgumentCaptor sublistenerCaptor = sublistenerCaptor3;
+ for (int i = 0; i < 9999; i++) {
+ ClientStream mockStream = mock(ClientStream.class);
+ doReturn(mockStream).when(retriableStreamRecorder).newSubstream(0);
+ sublistenerCaptor.getValue()
+ .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), MISCARRIED, new Metadata());
+ if (i == 9998) {
+ verify(retriableStreamRecorder).postCommit();
+ verify(masterListener)
+ .closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
+ } else {
+ verify(retriableStreamRecorder, never()).postCommit();
+ sublistenerCaptor = ArgumentCaptor.forClass(ClientStreamListener.class);
+ verify(mockStream).start(sublistenerCaptor.capture());
+ }
+ }
+ }
+
@Test
public void normalRetry_thenNoTransparentRetry_butNormalRetry() {
ClientStream mockStream1 = mock(ClientStream.class);
diff --git a/cronet/README.md b/cronet/README.md
index d53da56a8d7..d8861e5fc4b 100644
--- a/cronet/README.md
+++ b/cronet/README.md
@@ -26,7 +26,7 @@ In your app module's `build.gradle` file, include a dependency on both `grpc-cro
Google Play Services Client Library for Cronet
```
-implementation 'io.grpc:grpc-cronet:1.43.1'
+implementation 'io.grpc:grpc-cronet:1.45.0'
implementation 'com.google.android.gms:play-services-cronet:16.0.0'
```
diff --git a/cronet/build.gradle b/cronet/build.gradle
index e0a0b7b53a7..d66eaf3a182 100644
--- a/cronet/build.gradle
+++ b/cronet/build.gradle
@@ -70,12 +70,12 @@ task javadocs(type: Javadoc) {
}
task javadocJar(type: Jar, dependsOn: javadocs) {
- classifier = 'javadoc'
+ archiveClassifier = 'javadoc'
from javadocs.destinationDir
}
task sourcesJar(type: Jar) {
- classifier = 'sources'
+ archiveClassifier = 'sources'
from android.sourceSets.main.java.srcDirs
}
diff --git a/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java b/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java
index 7329ed08c5d..d44b716146e 100644
--- a/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java
+++ b/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java
@@ -44,7 +44,7 @@
import java.lang.reflect.Method;
import java.nio.Buffer;
import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -408,10 +408,10 @@ private void setGrpcHeaders(BidirectionalStream.Builder builder) {
// String and byte array.
byte[][] serializedHeaders = TransportFrameUtil.toHttp2Headers(headers);
for (int i = 0; i < serializedHeaders.length; i += 2) {
- String key = new String(serializedHeaders[i], StandardCharsets.UTF_8);
+ String key = new String(serializedHeaders[i], Charset.forName("UTF-8"));
// TODO(ericgribkoff): log an error or throw an exception
if (isApplicationHeader(key)) {
- String value = new String(serializedHeaders[i + 1], StandardCharsets.UTF_8);
+ String value = new String(serializedHeaders[i + 1], Charset.forName("UTF-8"));
builder.addHeader(key, value);
}
}
@@ -588,8 +588,8 @@ private void reportHeaders(List> headers, boolean endO
byte[][] headerValues = new byte[headerList.size()][];
for (int i = 0; i < headerList.size(); i += 2) {
- headerValues[i] = headerList.get(i).getBytes(StandardCharsets.UTF_8);
- headerValues[i + 1] = headerList.get(i + 1).getBytes(StandardCharsets.UTF_8);
+ headerValues[i] = headerList.get(i).getBytes(Charset.forName("UTF-8"));
+ headerValues[i + 1] = headerList.get(i + 1).getBytes(Charset.forName("UTF-8"));
}
Metadata metadata =
InternalMetadata.newMetadata(TransportFrameUtil.toRawSerializedHeaders(headerValues));
diff --git a/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java b/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
index 9b63601d717..1d17dfe9be5 100644
--- a/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
+++ b/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
@@ -46,7 +46,7 @@
import java.io.ByteArrayInputStream;
import java.nio.Buffer;
import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@@ -168,7 +168,7 @@ public void write() {
for (int i = 0; i < 5; ++i) {
requests[i] = new String("request" + String.valueOf(i));
buffers[i] = allocator.allocate(requests[i].length());
- buffers[i].write(requests[i].getBytes(StandardCharsets.UTF_8), 0, requests[i].length());
+ buffers[i].write(requests[i].getBytes(Charset.forName("UTF-8")), 0, requests[i].length());
// The 3rd and 5th writeFrame calls have flush=true.
clientStream.abstractClientStreamSink().writeFrame(buffers[i], false, i == 2 || i == 4, 1);
}
@@ -245,7 +245,7 @@ public void read() {
verify(cronetStream, times(0)).read(isA(ByteBuffer.class));
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
ArgumentCaptor metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
@@ -261,7 +261,7 @@ public void read() {
callback.onReadCompleted(
cronetStream,
info,
- createMessageFrame(new String("response1").getBytes(StandardCharsets.UTF_8)),
+ createMessageFrame(new String("response1").getBytes(Charset.forName("UTF-8"))),
false);
// Haven't request any message, so no callback is called here.
verify(clientListener, times(0)).messagesAvailable(isA(MessageProducer.class));
@@ -293,7 +293,7 @@ public void streamSucceeded() {
CronetWritableBufferAllocator allocator = new CronetWritableBufferAllocator();
String request = new String("request");
WritableBuffer writableBuffer = allocator.allocate(request.length());
- writableBuffer.write(request.getBytes(StandardCharsets.UTF_8), 0, request.length());
+ writableBuffer.write(request.getBytes(Charset.forName("UTF-8")), 0, request.length());
clientStream.abstractClientStreamSink().writeFrame(writableBuffer, false, true, 1);
ArgumentCaptor bufferCaptor = ArgumentCaptor.forClass(ByteBuffer.class);
verify(cronetStream, times(1)).write(bufferCaptor.capture(), isA(Boolean.class));
@@ -305,14 +305,14 @@ public void streamSucceeded() {
clientStream.request(2);
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
// Receive one message
callback.onReadCompleted(
cronetStream,
info,
- createMessageFrame(new String("response").getBytes(StandardCharsets.UTF_8)),
+ createMessageFrame(new String("response").getBytes(Charset.forName("UTF-8"))),
false);
verify(clientListener, times(1)).messagesAvailable(isA(MessageProducer.class));
verify(cronetStream, times(2)).read(isA(ByteBuffer.class));
@@ -363,7 +363,7 @@ public void streamSucceededWithGrpcError() {
clientStream.request(2);
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
@@ -418,7 +418,7 @@ public void streamFailedAfterResponseHeaderReceived() {
// Receive response header
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
CronetException exception = mock(CronetException.class);
@@ -446,7 +446,7 @@ public void streamFailedAfterTrailerReceived() {
// Receive response header
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
// Report trailer but not endOfStream.
@@ -478,7 +478,7 @@ public void streamFailedAfterTrailerAndEndOfStreamReceived() {
// Receive response header
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
// Report trailer and endOfStream
@@ -531,7 +531,7 @@ public void reportTrailersWhenTrailersReceivedBeforeReadClosed() {
callback.onStreamReady(cronetStream);
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
// Receive trailer first
((CronetClientStream.BidirectionalStreamCallback) callback)
@@ -560,7 +560,7 @@ public void reportTrailersWhenTrailersReceivedAfterReadClosed() {
callback.onStreamReady(cronetStream);
UrlResponseInfo info =
new UrlResponseInfoImpl(
- new ArrayList(), 200, "", responseHeader("200"), false, "", "");
+ new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
callback.onResponseHeadersReceived(cronetStream, info);
// Receive cronet's endOfStream
callback.onReadCompleted(cronetStream, null, ByteBuffer.allocate(0), true);
@@ -688,7 +688,7 @@ public void getUnaryRequest() {
.newBidirectionalStreamBuilder(
isA(String.class), isA(BidirectionalStream.Callback.class), isA(Executor.class));
- byte[] msg = "request".getBytes(StandardCharsets.UTF_8);
+ byte[] msg = "request".getBytes(Charset.forName("UTF-8"));
stream.writeMessage(new ByteArrayInputStream(msg));
// We still haven't built the stream or sent anything.
verify(cronetStream, times(0)).write(isA(ByteBuffer.class), isA(Boolean.class));
diff --git a/documentation/android-channel-builder.md b/documentation/android-channel-builder.md
index 09c0bef179a..2fb3f11d4dc 100644
--- a/documentation/android-channel-builder.md
+++ b/documentation/android-channel-builder.md
@@ -36,8 +36,8 @@ In your `build.gradle` file, include a dependency on both `grpc-android` and
`grpc-okhttp`:
```
-implementation 'io.grpc:grpc-android:1.43.1'
-implementation 'io.grpc:grpc-okhttp:1.43.1'
+implementation 'io.grpc:grpc-android:1.45.0'
+implementation 'io.grpc:grpc-okhttp:1.45.0'
```
You also need permission to access the device's network state in your
diff --git a/examples/android/clientcache/app/build.gradle b/examples/android/clientcache/app/build.gradle
index a71611df7a5..0d190b6f55c 100644
--- a/examples/android/clientcache/app/build.gradle
+++ b/examples/android/clientcache/app/build.gradle
@@ -34,7 +34,7 @@ android {
protobuf {
protoc { artifact = 'com.google.protobuf:protoc:3.19.2' }
plugins {
- grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.45.0' // CURRENT_GRPC_VERSION
}
}
generateProtoTasks {
@@ -54,12 +54,12 @@ dependencies {
implementation 'com.android.support:appcompat-v7:27.0.2'
// You need to build grpc-java to obtain these libraries below.
- implementation 'io.grpc:grpc-okhttp:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-protobuf-lite:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-stub:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-okhttp:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-protobuf-lite:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-stub:1.45.0' // CURRENT_GRPC_VERSION
implementation 'org.apache.tomcat:annotations-api:6.0.53'
testImplementation 'junit:junit:4.12'
testImplementation 'com.google.truth:truth:1.0.1'
- testImplementation 'io.grpc:grpc-testing:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ testImplementation 'io.grpc:grpc-testing:1.45.0' // CURRENT_GRPC_VERSION
}
diff --git a/examples/android/helloworld/app/build.gradle b/examples/android/helloworld/app/build.gradle
index cc84e9bcc5c..d4ba7520acc 100644
--- a/examples/android/helloworld/app/build.gradle
+++ b/examples/android/helloworld/app/build.gradle
@@ -32,7 +32,7 @@ android {
protobuf {
protoc { artifact = 'com.google.protobuf:protoc:3.19.2' }
plugins {
- grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.45.0' // CURRENT_GRPC_VERSION
}
}
generateProtoTasks {
@@ -52,8 +52,8 @@ dependencies {
implementation 'com.android.support:appcompat-v7:27.0.2'
// You need to build grpc-java to obtain these libraries below.
- implementation 'io.grpc:grpc-okhttp:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-protobuf-lite:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-stub:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-okhttp:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-protobuf-lite:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-stub:1.45.0' // CURRENT_GRPC_VERSION
implementation 'org.apache.tomcat:annotations-api:6.0.53'
}
diff --git a/examples/android/routeguide/app/build.gradle b/examples/android/routeguide/app/build.gradle
index 5a43416a5fb..463f0b4ee28 100644
--- a/examples/android/routeguide/app/build.gradle
+++ b/examples/android/routeguide/app/build.gradle
@@ -32,7 +32,7 @@ android {
protobuf {
protoc { artifact = 'com.google.protobuf:protoc:3.19.2' }
plugins {
- grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.45.0' // CURRENT_GRPC_VERSION
}
}
generateProtoTasks {
@@ -52,8 +52,8 @@ dependencies {
implementation 'com.android.support:appcompat-v7:27.0.2'
// You need to build grpc-java to obtain these libraries below.
- implementation 'io.grpc:grpc-okhttp:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-protobuf-lite:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-stub:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-okhttp:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-protobuf-lite:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-stub:1.45.0' // CURRENT_GRPC_VERSION
implementation 'org.apache.tomcat:annotations-api:6.0.53'
}
diff --git a/examples/android/strictmode/app/build.gradle b/examples/android/strictmode/app/build.gradle
index ad74597ed27..06e88663bc7 100644
--- a/examples/android/strictmode/app/build.gradle
+++ b/examples/android/strictmode/app/build.gradle
@@ -33,7 +33,7 @@ android {
protobuf {
protoc { artifact = 'com.google.protobuf:protoc:3.19.2' }
plugins {
- grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.45.0' // CURRENT_GRPC_VERSION
}
}
generateProtoTasks {
@@ -53,8 +53,8 @@ dependencies {
implementation 'com.android.support:appcompat-v7:28.0.0'
// You need to build grpc-java to obtain these libraries below.
- implementation 'io.grpc:grpc-okhttp:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-protobuf-lite:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
- implementation 'io.grpc:grpc-stub:1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-okhttp:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-protobuf-lite:1.45.0' // CURRENT_GRPC_VERSION
+ implementation 'io.grpc:grpc-stub:1.45.0' // CURRENT_GRPC_VERSION
implementation 'org.apache.tomcat:annotations-api:6.0.53'
}
diff --git a/examples/build.gradle b/examples/build.gradle
index 45648d4af85..76bd1082811 100644
--- a/examples/build.gradle
+++ b/examples/build.gradle
@@ -14,15 +14,15 @@ repositories {
mavenLocal()
}
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
// are looking at a tagged version of the example and not "master"!
// Feel free to delete the comment at the next line. It is just for safely
// updating the version in our release process.
-def grpcVersion = '1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.45.0' // CURRENT_GRPC_VERSION
def protobufVersion = '3.19.2'
def protocVersion = protobufVersion
diff --git a/examples/example-alts/build.gradle b/examples/example-alts/build.gradle
index de4e11fd916..887357c0334 100644
--- a/examples/example-alts/build.gradle
+++ b/examples/example-alts/build.gradle
@@ -15,15 +15,15 @@ repositories {
mavenLocal()
}
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
// are looking at a tagged version of the example and not "master"!
// Feel free to delete the comment at the next line. It is just for safely
// updating the version in our release process.
-def grpcVersion = '1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.45.0' // CURRENT_GRPC_VERSION
def protocVersion = '3.19.2'
dependencies {
diff --git a/examples/example-gauth/build.gradle b/examples/example-gauth/build.gradle
index fdde6e01aff..cd617c03681 100644
--- a/examples/example-gauth/build.gradle
+++ b/examples/example-gauth/build.gradle
@@ -15,15 +15,15 @@ repositories {
mavenLocal()
}
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
// are looking at a tagged version of the example and not "master"!
// Feel free to delete the comment at the next line. It is just for safely
// updating the version in our release process.
-def grpcVersion = '1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.45.0' // CURRENT_GRPC_VERSION
def protobufVersion = '3.19.2'
def protocVersion = protobufVersion
diff --git a/examples/example-gauth/pom.xml b/examples/example-gauth/pom.xml
index 2ccd6654757..273bf4fe640 100644
--- a/examples/example-gauth/pom.xml
+++ b/examples/example-gauth/pom.xml
@@ -6,13 +6,13 @@
jar
- 1.44.0-SNAPSHOT
+ 1.45.0
example-gauth
https://github.com/grpc/grpc-java
UTF-8
- 1.44.0-SNAPSHOT
+ 1.45.0
3.19.2
1.7
diff --git a/examples/example-hostname/build.gradle b/examples/example-hostname/build.gradle
index f40528e56ea..bc04e0da888 100644
--- a/examples/example-hostname/build.gradle
+++ b/examples/example-hostname/build.gradle
@@ -13,15 +13,15 @@ repositories {
mavenLocal()
}
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
// are looking at a tagged version of the example and not "master"!
// Feel free to delete the comment at the next line. It is just for safely
// updating the version in our release process.
-def grpcVersion = '1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.45.0' // CURRENT_GRPC_VERSION
def protobufVersion = '3.19.2'
dependencies {
diff --git a/examples/example-hostname/pom.xml b/examples/example-hostname/pom.xml
index 31445d405de..01b58578fba 100644
--- a/examples/example-hostname/pom.xml
+++ b/examples/example-hostname/pom.xml
@@ -6,13 +6,13 @@
jar
- 1.44.0-SNAPSHOT
+ 1.45.0
example-hostname
https://github.com/grpc/grpc-java
UTF-8
- 1.44.0-SNAPSHOT
+ 1.45.0
3.19.2
1.7
diff --git a/examples/example-jwt-auth/build.gradle b/examples/example-jwt-auth/build.gradle
index 8f962a2ffc8..b1ba3b84662 100644
--- a/examples/example-jwt-auth/build.gradle
+++ b/examples/example-jwt-auth/build.gradle
@@ -14,15 +14,15 @@ repositories {
mavenLocal()
}
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
// are looking at a tagged version of the example and not "master"!
// Feel free to delete the comment at the next line. It is just for safely
// updating the version in our release process.
-def grpcVersion = '1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.45.0' // CURRENT_GRPC_VERSION
def protobufVersion = '3.19.2'
def protocVersion = protobufVersion
diff --git a/examples/example-jwt-auth/pom.xml b/examples/example-jwt-auth/pom.xml
index f026be38467..7724d7309b0 100644
--- a/examples/example-jwt-auth/pom.xml
+++ b/examples/example-jwt-auth/pom.xml
@@ -7,13 +7,13 @@
jar
- 1.44.0-SNAPSHOT
+ 1.45.0
example-jwt-auth
https://github.com/grpc/grpc-java
UTF-8
- 1.44.0-SNAPSHOT
+ 1.45.0
3.19.2
3.19.2
diff --git a/examples/example-tls/build.gradle b/examples/example-tls/build.gradle
index b3b8372e1c4..07656db6b59 100644
--- a/examples/example-tls/build.gradle
+++ b/examples/example-tls/build.gradle
@@ -15,15 +15,15 @@ repositories {
mavenLocal()
}
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
// are looking at a tagged version of the example and not "master"!
// Feel free to delete the comment at the next line. It is just for safely
// updating the version in our release process.
-def grpcVersion = '1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.45.0' // CURRENT_GRPC_VERSION
def protocVersion = '3.19.2'
dependencies {
diff --git a/examples/example-tls/pom.xml b/examples/example-tls/pom.xml
index 193e05fd812..fb6fe00a0c1 100644
--- a/examples/example-tls/pom.xml
+++ b/examples/example-tls/pom.xml
@@ -6,13 +6,13 @@
jar
- 1.44.0-SNAPSHOT
+ 1.45.0
example-tls
https://github.com/grpc/grpc-java
UTF-8
- 1.44.0-SNAPSHOT
+ 1.45.0
3.19.2
2.0.34.Final
diff --git a/examples/example-xds/build.gradle b/examples/example-xds/build.gradle
index 2d35f5c40d9..880f8a0014f 100644
--- a/examples/example-xds/build.gradle
+++ b/examples/example-xds/build.gradle
@@ -14,15 +14,15 @@ repositories {
mavenLocal()
}
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
// are looking at a tagged version of the example and not "master"!
// Feel free to delete the comment at the next line. It is just for safely
// updating the version in our release process.
-def grpcVersion = '1.44.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.45.0' // CURRENT_GRPC_VERSION
def nettyTcNativeVersion = '2.0.31.Final'
def protocVersion = '3.19.2'
diff --git a/examples/pom.xml b/examples/pom.xml
index 525fb616fa0..9a140e482f2 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -6,13 +6,13 @@
jar
- 1.44.0-SNAPSHOT
+ 1.45.0
examples
https://github.com/grpc/grpc-java
UTF-8
- 1.44.0-SNAPSHOT
+ 1.45.0
3.19.2
3.19.2
diff --git a/examples/src/main/java/io/grpc/examples/advanced/JsonMarshaller.java b/examples/src/main/java/io/grpc/examples/advanced/JsonMarshaller.java
index fbe3fa50afc..8b3068cc009 100644
--- a/examples/src/main/java/io/grpc/examples/advanced/JsonMarshaller.java
+++ b/examples/src/main/java/io/grpc/examples/advanced/JsonMarshaller.java
@@ -30,7 +30,6 @@
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
/**
* A {@link Marshaller} for JSON. This marshals in the Protobuf 3 format described here:
@@ -59,7 +58,7 @@ public static Marshaller jsonMarshaller(final T defaultIn
public static Marshaller jsonMarshaller(
final T defaultInstance, final Parser parser, final Printer printer) {
- final Charset charset = StandardCharsets.UTF_8;
+ final Charset charset = Charset.forName("UTF-8");
return new Marshaller() {
@Override
diff --git a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java
index 0794674091f..6e49492da06 100644
--- a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java
+++ b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java
@@ -22,7 +22,7 @@
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.List;
/**
@@ -58,7 +58,7 @@ public static URL getDefaultFeaturesFile() {
public static List parseFeatures(URL file) throws IOException {
InputStream input = file.openStream();
try {
- Reader reader = new InputStreamReader(input, StandardCharsets.UTF_8);
+ Reader reader = new InputStreamReader(input, Charset.forName("UTF-8"));
try {
FeatureDatabase.Builder database = FeatureDatabase.newBuilder();
JsonFormat.parser().merge(reader, database);
diff --git a/googleapis/build.gradle b/googleapis/build.gradle
new file mode 100644
index 00000000000..69449e8a02b
--- /dev/null
+++ b/googleapis/build.gradle
@@ -0,0 +1,36 @@
+plugins {
+ id "java-library"
+ id "maven-publish"
+
+ id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: googleapis'
+
+dependencies {
+ api project(':grpc-api')
+ implementation project(':grpc-alts'),
+ project(':grpc-core'),
+ project(':grpc-xds'),
+ libraries.guava
+ testImplementation project(':grpc-core').sourceSets.test.output
+
+ signature "org.codehaus.mojo.signature:java17:1.0@signature"
+}
+
+publishing {
+ publications {
+ maven(MavenPublication) {
+ pom {
+ withXml {
+ // Since internal APIs are used, pin the version.
+ asNode().dependencies.'*'.findAll() { dep ->
+ dep.artifactId.text() in ['grpc-alts', 'grpc-xds']
+ }.each() { core ->
+ core.version*.value = "[" + core.version.text() + "]"
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolver.java b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolver.java
similarity index 93%
rename from xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolver.java
rename to googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolver.java
index 2845d0a00e8..fb330b82bde 100644
--- a/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolver.java
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolver.java
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-package io.grpc.xds;
+package io.grpc.googleapis;
import static com.google.common.base.Preconditions.checkNotNull;
@@ -32,7 +32,6 @@
import io.grpc.internal.GrpcUtil;
import io.grpc.internal.SharedResourceHolder;
import io.grpc.internal.SharedResourceHolder.Resource;
-import io.grpc.xds.XdsNameResolverProvider.XdsClientPoolFactory;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
@@ -40,6 +39,7 @@
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
+import java.util.Map;
import java.util.Random;
import java.util.concurrent.Executor;
@@ -70,7 +70,7 @@ final class GoogleCloudToProdNameResolver extends NameResolver {
private final String authority;
private final SynchronizationContext syncContext;
private final Resource executorResource;
- private final XdsClientPoolFactory xdsClientPoolFactory;
+ private final BootstrapSetter bootstrapSetter;
private final NameResolver delegate;
private final Random rand;
private final boolean usingExecutorResource;
@@ -84,17 +84,16 @@ final class GoogleCloudToProdNameResolver extends NameResolver {
private boolean shutdown;
GoogleCloudToProdNameResolver(URI targetUri, Args args, Resource executorResource,
- XdsClientPoolFactory xdsClientPoolFactory) {
- this(targetUri, args, executorResource, new Random(), xdsClientPoolFactory,
+ BootstrapSetter bootstrapSetter) {
+ this(targetUri, args, executorResource, new Random(), bootstrapSetter,
NameResolverRegistry.getDefaultRegistry().asFactory());
}
@VisibleForTesting
GoogleCloudToProdNameResolver(URI targetUri, Args args, Resource executorResource,
- Random rand, XdsClientPoolFactory xdsClientPoolFactory,
- NameResolver.Factory nameResolverFactory) {
+ Random rand, BootstrapSetter bootstrapSetter, NameResolver.Factory nameResolverFactory) {
this.executorResource = checkNotNull(executorResource, "executorResource");
- this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
+ this.bootstrapSetter = checkNotNull(bootstrapSetter, "bootstrapSetter");
this.rand = checkNotNull(rand, "rand");
String targetPath = checkNotNull(checkNotNull(targetUri, "targetUri").getPath(), "targetPath");
Preconditions.checkArgument(
@@ -159,7 +158,7 @@ public void run() {
@Override
public void run() {
if (!shutdown && finalRawBootstrap != null) {
- xdsClientPoolFactory.setBootstrapOverride(finalRawBootstrap);
+ bootstrapSetter.setBootstrap(finalRawBootstrap);
delegate.start(listener);
succeeded = true;
}
@@ -175,7 +174,7 @@ public void run() {
private ImmutableMap generateBootstrap(String zone, boolean supportIpv6) {
ImmutableMap.Builder nodeBuilder = ImmutableMap.builder();
- nodeBuilder.put("id", "C2P-" + rand.nextInt());
+ nodeBuilder.put("id", "C2P-" + (rand.nextInt() & Integer.MAX_VALUE));
if (!zone.isEmpty()) {
nodeBuilder.put("locality", ImmutableMap.of("zone", zone));
}
@@ -284,4 +283,8 @@ public HttpURLConnection createConnection(String url) throws IOException {
interface HttpConnectionProvider {
HttpURLConnection createConnection(String url) throws IOException;
}
+
+ public interface BootstrapSetter {
+ void setBootstrap(Map bootstrap);
+ }
}
diff --git a/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolverProvider.java b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProvider.java
similarity index 75%
rename from xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolverProvider.java
rename to googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProvider.java
index e7f9cb45ff8..ac39ab1e625 100644
--- a/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolverProvider.java
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProvider.java
@@ -14,14 +14,16 @@
* limitations under the License.
*/
-package io.grpc.xds;
+package io.grpc.googleapis;
import io.grpc.Internal;
import io.grpc.NameResolver;
import io.grpc.NameResolver.Args;
import io.grpc.NameResolverProvider;
import io.grpc.internal.GrpcUtil;
+import io.grpc.xds.InternalSharedXdsClientPoolProvider;
import java.net.URI;
+import java.util.Map;
/**
* A provider for {@link GoogleCloudToProdNameResolver}.
@@ -36,7 +38,7 @@ public NameResolver newNameResolver(URI targetUri, Args args) {
if (SCHEME.equals(targetUri.getScheme())) {
return new GoogleCloudToProdNameResolver(
targetUri, args, GrpcUtil.SHARED_CHANNEL_EXECUTOR,
- SharedXdsClientPoolProvider.getDefaultProvider());
+ new SharedXdsClientPoolProviderBootstrapSetter());
}
return null;
}
@@ -55,4 +57,12 @@ protected boolean isAvailable() {
protected int priority() {
return 4;
}
+
+ private static final class SharedXdsClientPoolProviderBootstrapSetter
+ implements GoogleCloudToProdNameResolver.BootstrapSetter {
+ @Override
+ public void setBootstrap(Map bootstrap) {
+ InternalSharedXdsClientPoolProvider.setDefaultProviderBootstrapOverride(bootstrap);
+ }
+ }
}
diff --git a/googleapis/src/main/resources/META-INF/services/io.grpc.NameResolverProvider b/googleapis/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
new file mode 100644
index 00000000000..553e5409180
--- /dev/null
+++ b/googleapis/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
@@ -0,0 +1 @@
+io.grpc.googleapis.GoogleCloudToProdNameResolverProvider
diff --git a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverProviderTest.java b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProviderTest.java
similarity index 98%
rename from xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverProviderTest.java
rename to googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProviderTest.java
index cc6621028c8..e6ef1696dc0 100644
--- a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverProviderTest.java
+++ b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProviderTest.java
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-package io.grpc.xds;
+package io.grpc.googleapis;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;
diff --git a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverTest.java b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverTest.java
similarity index 89%
rename from xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverTest.java
rename to googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverTest.java
index 58be7108405..562798c0183 100644
--- a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverTest.java
+++ b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverTest.java
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-package io.grpc.xds;
+package io.grpc.googleapis;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
@@ -33,12 +33,10 @@
import io.grpc.Status;
import io.grpc.Status.Code;
import io.grpc.SynchronizationContext;
+import io.grpc.googleapis.GoogleCloudToProdNameResolver.HttpConnectionProvider;
import io.grpc.internal.FakeClock;
import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.ObjectPool;
import io.grpc.internal.SharedResourceHolder.Resource;
-import io.grpc.xds.GoogleCloudToProdNameResolver.HttpConnectionProvider;
-import io.grpc.xds.XdsNameResolverProvider.XdsClientPoolFactory;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.net.HttpURLConnection;
@@ -50,7 +48,6 @@
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nullable;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
@@ -88,7 +85,7 @@ public void uncaughtException(Thread t, Throwable e) {
.setChannelLogger(mock(ChannelLogger.class))
.build();
private final FakeClock fakeExecutor = new FakeClock();
- private final FakeXdsClientPoolFactory fakeXdsClientPoolFactory = new FakeXdsClientPoolFactory();
+ private final FakeBootstrapSetter fakeBootstrapSetter = new FakeBootstrapSetter();
private final Resource fakeExecutorResource = new Resource() {
@Override
public Executor create() {
@@ -104,8 +101,7 @@ public void close(Executor instance) {}
@Mock
private NameResolver.Listener2 mockListener;
- @Mock
- private Random mockRandom;
+ private Random random = new Random(1);
@Captor
private ArgumentCaptor errorCaptor;
private boolean originalIsOnGcp;
@@ -114,7 +110,6 @@ public void close(Executor instance) {}
@Before
public void setUp() {
- when(mockRandom.nextInt()).thenReturn(123456789);
nsRegistry.register(new FakeNsProvider("dns"));
nsRegistry.register(new FakeNsProvider("xds"));
originalIsOnGcp = GoogleCloudToProdNameResolver.isOnGcp;
@@ -146,7 +141,7 @@ public HttpURLConnection createConnection(String url) throws IOException {
}
};
resolver = new GoogleCloudToProdNameResolver(
- TARGET_URI, args, fakeExecutorResource, mockRandom, fakeXdsClientPoolFactory,
+ TARGET_URI, args, fakeExecutorResource, random, fakeBootstrapSetter,
nsRegistry.asFactory());
resolver.setHttpConnectionProvider(httpConnections);
}
@@ -180,10 +175,10 @@ public void onGcpAndNoProvidedBootstrapDelegateToXds() {
fakeExecutor.runDueTasks();
assertThat(delegatedResolver.keySet()).containsExactly("xds");
verify(Iterables.getOnlyElement(delegatedResolver.values())).start(mockListener);
- Map bootstrap = fakeXdsClientPoolFactory.bootstrapRef.get();
+ Map bootstrap = fakeBootstrapSetter.bootstrapRef.get();
Map node = (Map) bootstrap.get("node");
assertThat(node).containsExactly(
- "id", "C2P-123456789",
+ "id", "C2P-991614323",
"locality", ImmutableMap.of("zone", ZONE),
"metadata", ImmutableMap.of("TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", true));
Map server = Iterables.getOnlyElement(
@@ -248,23 +243,13 @@ public String getDefaultScheme() {
}
}
- private static final class FakeXdsClientPoolFactory implements XdsClientPoolFactory {
+ private static final class FakeBootstrapSetter
+ implements GoogleCloudToProdNameResolver.BootstrapSetter {
private final AtomicReference> bootstrapRef = new AtomicReference<>();
@Override
- public void setBootstrapOverride(Map bootstrap) {
+ public void setBootstrap(Map bootstrap) {
bootstrapRef.set(bootstrap);
}
-
- @Override
- @Nullable
- public ObjectPool get() {
- throw new UnsupportedOperationException("Should not be called");
- }
-
- @Override
- public ObjectPool getOrCreate() {
- throw new UnsupportedOperationException("Should not be called");
- }
}
}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java
index 8ac50419d5f..914db12e5a8 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java
@@ -40,7 +40,6 @@
import java.io.File;
import java.io.FileInputStream;
import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nullable;
@@ -51,7 +50,7 @@
*/
public class TestServiceClient {
- private static final Charset UTF_8 = StandardCharsets.UTF_8;
+ private static final Charset UTF_8 = Charset.forName("UTF-8");
/**
* The main application allowing this client to be launched from the command line.
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java
index fdd3ac63011..208eb40c438 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java
@@ -52,7 +52,7 @@
import io.grpc.testing.integration.Messages.SimpleResponse;
import io.grpc.testing.integration.TestServiceGrpc.TestServiceBlockingStub;
import io.grpc.testing.integration.TransportCompressionTest.Fzip;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@@ -312,6 +312,6 @@ public void onHeaders(Metadata headers) {
}
private static void assertEqualsString(String expected, byte[] actual) {
- assertEquals(expected, new String(actual, StandardCharsets.US_ASCII));
+ assertEquals(expected, new String(actual, Charset.forName("US-ASCII")));
}
}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java
index 4d7c8bdbca7..c86bd8070a0 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java
@@ -39,17 +39,13 @@
import io.netty.channel.ChannelHandler;
import io.netty.handler.codec.http2.Http2Stream;
import io.netty.util.AsciiString;
-import io.netty.util.concurrent.DefaultThreadFactory;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.After;
-import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
@@ -80,16 +76,6 @@ public class NettyFlowControlTest {
private int proxyPort;
private int serverPort;
- private static final ThreadPoolExecutor executor =
- new ThreadPoolExecutor(1, 10, 1, TimeUnit.SECONDS, new LinkedBlockingQueue(),
- new DefaultThreadFactory("flowcontrol-test-pool", true));
-
-
- @AfterClass
- public static void shutDownTests() {
- executor.shutdown();
- }
-
@Before
public void initTest() {
startServer(REGULAR_WINDOW);
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/RetryTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/RetryTest.java
index 80cf83b0939..229d873571a 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/RetryTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/RetryTest.java
@@ -74,7 +74,6 @@
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
-import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -459,33 +458,41 @@ public long nanoTime() {
assertRetryStatsRecorded(0, 0, 0);
}
- @Ignore("flaky because old transportReportStatus() is not completely migrated yet")
@Test
public void transparentRetryStatsRecorded() throws Exception {
startNewServer();
createNewChannel();
- final AtomicBoolean transparentRetryTriggered = new AtomicBoolean();
+ final AtomicBoolean originalAttemptFailed = new AtomicBoolean();
class TransparentRetryTriggeringTracer extends ClientStreamTracer {
@Override
public void streamCreated(Attributes transportAttrs, Metadata metadata) {
- if (transparentRetryTriggered.get()) {
+ if (originalAttemptFailed.get()) {
return;
}
+ // Send GOAWAY from server. The client may either receive GOAWAY or create the underlying
+ // netty stream and write headers first, even we await server termination as below.
+ // In the latter case, we rerun the test. We can also call localServer.shutdown() to trigger
+ // GOAWAY, but it takes a lot longer time to gracefully shut down.
localServer.shutdownNow();
+ try {
+ localServer.awaitTermination();
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new AssertionError(e);
+ }
}
@Override
public void streamClosed(Status status) {
- if (transparentRetryTriggered.get()) {
+ if (originalAttemptFailed.get()) {
return;
}
- transparentRetryTriggered.set(true);
+ originalAttemptFailed.set(true);
try {
startNewServer();
channel.resetConnectBackoff();
- channel.getState(true);
} catch (Exception e) {
throw new AssertionError("local server can not be restarted", e);
}
@@ -502,13 +509,28 @@ public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata header
CallOptions callOptions = CallOptions.DEFAULT
.withWaitForReady()
.withStreamTracerFactory(new TransparentRetryTracerFactory());
- ClientCall call = channel.newCall(clientStreamingMethod, callOptions);
- call.start(mockCallListener, new Metadata());
- assertRpcStartedRecorded();
- assertRpcStatusRecorded(Code.UNAVAILABLE, 0, 0);
- assertRpcStartedRecorded();
- call.cancel("cancel", null);
- assertRpcStatusRecorded(Code.CANCELLED, 0, 0);
+ while (true) {
+ ClientCall call = channel.newCall(clientStreamingMethod, callOptions);
+ call.start(mockCallListener, new Metadata());
+ assertRpcStartedRecorded(); // original attempt
+ MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+ assertThat(record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT))
+ .isEqualTo(1);
+ TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+ if (statusTag.asString().equals(Code.UNAVAILABLE.toString())) {
+ break;
+ } else {
+ // Due to race condition, GOAWAY is not received/processed before the stream is closed due
+ // to connection error. Rerun the test.
+ assertThat(statusTag.asString()).isEqualTo(Code.UNKNOWN.toString());
+ assertRetryStatsRecorded(0, 0, 0);
+ originalAttemptFailed.set(false);
+ }
+ }
+ assertRpcStartedRecorded(); // retry attempt
+ ServerCall serverCall = serverCalls.poll(5, SECONDS);
+ serverCall.close(Status.INVALID_ARGUMENT, new Metadata());
+ assertRpcStatusRecorded(Code.INVALID_ARGUMENT, 0, 0);
assertRetryStatsRecorded(0, 1, 0);
}
}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java b/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java
index 19f22cb03f1..a93d51628e4 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java
@@ -51,7 +51,7 @@ public final class TrafficControlProxy {
private Socket serverSock;
private Socket clientSock;
private final ThreadPoolExecutor executor =
- new ThreadPoolExecutor(5, 10, 1, TimeUnit.SECONDS, new LinkedBlockingQueue(),
+ new ThreadPoolExecutor(5, 5, 1, TimeUnit.SECONDS, new LinkedBlockingQueue(),
new DefaultThreadFactory("proxy-pool", true));
/**
diff --git a/netty/shaded/build.gradle b/netty/shaded/build.gradle
index 6b1dad644d1..e2409a86d99 100644
--- a/netty/shaded/build.gradle
+++ b/netty/shaded/build.gradle
@@ -18,7 +18,8 @@ sourceSets { testShadow {} }
dependencies {
implementation project(':grpc-netty')
runtimeOnly libraries.netty_tcnative,
- libraries.netty_epoll
+ libraries.netty_epoll,
+ libraries.netty_epoll_arm64
testShadowImplementation files(shadowJar),
project(':grpc-testing-proto'),
project(':grpc-testing'),
@@ -29,12 +30,12 @@ dependencies {
}
jar {
- // Must use a different classifier to avoid conflicting with shadowJar
- classifier = 'original'
+ // Must use a different archiveClassifier to avoid conflicting with shadowJar
+ archiveClassifier = 'original'
}
shadowJar {
- classifier = null
+ archiveClassifier = null
dependencies {
include(project(':grpc-netty'))
include(dependency('io.netty:'))
diff --git a/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java b/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
index 459c313eded..25f4f9232cf 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
@@ -58,6 +58,7 @@ protected GrpcHttp2ConnectionHandler(
* @deprecated Use the two argument method instead.
*/
@Deprecated
+ @SuppressWarnings("InlineMeSuggester") // the caller should consider providing securityInfo
public void handleProtocolNegotiationCompleted(Attributes attrs) {
handleProtocolNegotiationCompleted(attrs, /*securityInfo=*/ null);
}
diff --git a/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java b/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
index 17801afa382..ca029fe7cfc 100644
--- a/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
@@ -24,6 +24,7 @@
import com.google.common.annotations.VisibleForTesting;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.InlineMe;
import io.grpc.Attributes;
import io.grpc.CallCredentials;
import io.grpc.ChannelCredentials;
@@ -393,6 +394,7 @@ public NettyChannelBuilder flowControlWindow(int flowControlWindow) {
* @deprecated Use {@link #maxInboundMetadataSize} instead
*/
@Deprecated
+ @InlineMe(replacement = "this.maxInboundMetadataSize(maxHeaderListSize)")
public NettyChannelBuilder maxHeaderListSize(int maxHeaderListSize) {
return maxInboundMetadataSize(maxHeaderListSize);
}
diff --git a/netty/src/main/java/io/grpc/netty/NettyClientHandler.java b/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
index 6dde8c825ef..80d11e54859 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
@@ -535,7 +535,7 @@ private void createStream(CreateStreamCommand command, ChannelPromise promise)
// The connection is going away (it is really the GOAWAY case),
// just terminate the stream now.
command.stream().transportReportStatus(
- lifecycleManager.getShutdownStatus(), RpcProgress.REFUSED, true, new Metadata());
+ lifecycleManager.getShutdownStatus(), RpcProgress.MISCARRIED, true, new Metadata());
promise.setFailure(lifecycleManager.getShutdownThrowable());
return;
}
@@ -576,7 +576,7 @@ private void createStream(CreateStreamCommand command, ChannelPromise promise)
// This should only be reachable during onGoAwayReceived, as otherwise
// getShutdownThrowable() != null
command.stream().setNonExistent();
- command.stream().transportReportStatus(s, RpcProgress.REFUSED, true, new Metadata());
+ command.stream().transportReportStatus(s, RpcProgress.MISCARRIED, true, new Metadata());
promise.setFailure(s.asRuntimeException());
return;
}
@@ -635,18 +635,24 @@ public void operationComplete(ChannelFuture future) throws Exception {
// Just forward on the success status to the original promise.
promise.setSuccess();
} else {
- final Throwable cause = future.cause();
+ Throwable cause = future.cause();
if (cause instanceof StreamBufferingEncoder.Http2GoAwayException) {
StreamBufferingEncoder.Http2GoAwayException e =
(StreamBufferingEncoder.Http2GoAwayException) cause;
Status status = statusFromH2Error(
Status.Code.UNAVAILABLE, "GOAWAY closed buffered stream",
e.errorCode(), e.debugData());
- stream.transportReportStatus(status, RpcProgress.REFUSED, true, new Metadata());
- promise.setFailure(status.asRuntimeException());
- } else {
- promise.setFailure(cause);
+ cause = status.asRuntimeException();
+ stream.transportReportStatus(status, RpcProgress.MISCARRIED, true, new Metadata());
+ } else if (cause instanceof StreamBufferingEncoder.Http2ChannelClosedException) {
+ Status status = lifecycleManager.getShutdownStatus();
+ if (status == null) {
+ status = Status.UNAVAILABLE.withCause(cause)
+ .withDescription("Connection closed while stream is buffered");
+ }
+ stream.transportReportStatus(status, RpcProgress.MISCARRIED, true, new Metadata());
}
+ promise.setFailure(cause);
}
}
});
diff --git a/netty/src/main/java/io/grpc/netty/NettyClientStream.java b/netty/src/main/java/io/grpc/netty/NettyClientStream.java
index 0e7e69635a8..9c6c12cc0f6 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientStream.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientStream.java
@@ -31,6 +31,7 @@
import io.grpc.MethodDescriptor;
import io.grpc.Status;
import io.grpc.internal.AbstractClientStream;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
import io.grpc.internal.Http2ClientStreamTransportState;
import io.grpc.internal.StatsTraceContext;
import io.grpc.internal.TransportTracer;
@@ -152,12 +153,18 @@ public void operationComplete(ChannelFuture future) throws Exception {
// Stream creation failed. Close the stream if not already closed.
// When the channel is shutdown, the lifecycle manager has a better view of the failure,
// especially before negotiation completes (because the negotiator commonly doesn't
- // receive the execeptionCaught because NettyClientHandler does not propagate it).
+ // receive the exceptionCaught because NettyClientHandler does not propagate it).
Status s = transportState().handler.getLifecycleManager().getShutdownStatus();
if (s == null) {
s = transportState().statusFromFailedFuture(future);
}
- transportState().transportReportStatus(s, true, new Metadata());
+ if (transportState().isNonExistent()) {
+ transportState().transportReportStatus(
+ s, RpcProgress.MISCARRIED, true, new Metadata());
+ } else {
+ transportState().transportReportStatus(
+ s, RpcProgress.PROCESSED, true, new Metadata());
+ }
}
}
};
@@ -268,7 +275,7 @@ void setNonExistent() {
}
boolean isNonExistent() {
- return this.id == NON_EXISTENT_ID;
+ return this.id == NON_EXISTENT_ID || this.id == 0;
}
/**
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java b/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
index 9b67cd21f19..ff5553eb116 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
@@ -26,6 +26,7 @@
import com.google.common.annotations.VisibleForTesting;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.InlineMe;
import io.grpc.Attributes;
import io.grpc.ExperimentalApi;
import io.grpc.Internal;
@@ -437,6 +438,7 @@ public NettyServerBuilder flowControlWindow(int flowControlWindow) {
* future release.
*/
@Deprecated
+ @InlineMe(replacement = "this.maxInboundMessageSize(maxMessageSize)")
public NettyServerBuilder maxMessageSize(int maxMessageSize) {
return maxInboundMessageSize(maxMessageSize);
}
@@ -458,6 +460,7 @@ public NettyServerBuilder maxInboundMessageSize(int bytes) {
* @deprecated Use {@link #maxInboundMetadataSize} instead
*/
@Deprecated
+ @InlineMe(replacement = "this.maxInboundMetadataSize(maxHeaderListSize)")
public NettyServerBuilder maxHeaderListSize(int maxHeaderListSize) {
return maxInboundMetadataSize(maxHeaderListSize);
}
diff --git a/netty/src/test/java/io/grpc/netty/KeepAliveEnforcerTest.java b/netty/src/test/java/io/grpc/netty/KeepAliveEnforcerTest.java
index 33c40390826..8dfeb990e2b 100644
--- a/netty/src/test/java/io/grpc/netty/KeepAliveEnforcerTest.java
+++ b/netty/src/test/java/io/grpc/netty/KeepAliveEnforcerTest.java
@@ -32,12 +32,12 @@ public class KeepAliveEnforcerTest {
@Test(expected = IllegalArgumentException.class)
public void negativeTime() {
- new KeepAliveEnforcer(true, -1, TimeUnit.NANOSECONDS);
+ KeepAliveEnforcer unused = new KeepAliveEnforcer(true, -1, TimeUnit.NANOSECONDS);
}
@Test(expected = NullPointerException.class)
public void nullTimeUnit() {
- new KeepAliveEnforcer(true, 1, null);
+ KeepAliveEnforcer unused = new KeepAliveEnforcer(true, 1, null);
}
@Test
diff --git a/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java b/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
index d0d48fe9b48..d47942858a3 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
@@ -18,6 +18,7 @@
import static com.google.common.base.Charsets.UTF_8;
import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.MISCARRIED;
import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
import static io.grpc.internal.ClientStreamListener.RpcProgress.REFUSED;
import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
@@ -378,7 +379,7 @@ public void receivedAbruptGoAwayShouldFailRacingQueuedStreamid() throws Exceptio
channelRead(goAwayFrame(0, 8 /* Cancel */, Unpooled.copiedBuffer("this is a test", UTF_8)));
ArgumentCaptor captor = ArgumentCaptor.forClass(Status.class);
- verify(streamListener).closed(captor.capture(), same(REFUSED),
+ verify(streamListener).closed(captor.capture(), same(MISCARRIED),
ArgumentMatchers.notNull());
assertEquals(Status.UNAVAILABLE.getCode(), captor.getValue().getCode());
assertEquals(
@@ -471,6 +472,20 @@ public void receivedGoAwayShouldFailBufferedStreams() throws Exception {
status.getDescription());
}
+ @Test
+ public void channelClosureShouldFailBufferedStreams() throws Exception {
+ receiveMaxConcurrentStreams(0);
+
+ ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+ channel().pipeline().fireChannelInactive();
+
+ assertTrue(future.isDone());
+ assertFalse(future.isSuccess());
+ ArgumentCaptor captor = ArgumentCaptor.forClass(Status.class);
+ verify(streamListener).closed(captor.capture(), same(MISCARRIED), ArgumentMatchers.notNull());
+ assertEquals(Status.UNAVAILABLE.getCode(), captor.getValue().getCode());
+ }
+
@Test
public void receivedGoAwayShouldFailNewStreams() throws Exception {
// Read a GOAWAY that indicates our stream was never processed by the server.
diff --git a/observability/build.gradle b/observability/build.gradle
new file mode 100644
index 00000000000..137e5f6978a
--- /dev/null
+++ b/observability/build.gradle
@@ -0,0 +1,40 @@
+plugins {
+ id "java-library"
+ id "maven-publish"
+
+ id "com.google.protobuf"
+ id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Observability"
+dependencies {
+ def cloudLoggingVersion = '3.6.1'
+
+ api project(':grpc-api'),
+ project(':grpc-alts')
+
+ implementation project(':grpc-protobuf'),
+ project(':grpc-stub'),
+ ('com.google.guava:guava:31.0.1-jre'),
+ ('com.google.errorprone:error_prone_annotations:2.11.0'),
+ ('com.google.auth:google-auth-library-credentials:1.4.0'),
+ ('org.checkerframework:checker-qual:3.20.0'),
+ ('com.google.auto.value:auto-value-annotations:1.9'),
+ ('com.google.http-client:google-http-client:1.41.0'),
+ ('com.google.http-client:google-http-client-gson:1.41.0'),
+ ('com.google.api.grpc:proto-google-common-protos:2.7.1'),
+ ("com.google.cloud:google-cloud-logging:${cloudLoggingVersion}")
+
+ testImplementation project(':grpc-testing'),
+ project(':grpc-testing-proto'),
+ project(':grpc-netty-shaded')
+ testImplementation (libraries.guava_testlib) {
+ exclude group: 'junit', module: 'junit'
+ }
+
+ signature "org.codehaus.mojo.signature:java18:1.0@signature"
+}
+
+configureProtoCompilation()
+
+[publishMavenPublicationToMavenRepository]*.onlyIf { false }
diff --git a/observability/src/main/java/io/grpc/observability/LoggingChannelProvider.java b/observability/src/main/java/io/grpc/observability/LoggingChannelProvider.java
new file mode 100644
index 00000000000..5011068c176
--- /dev/null
+++ b/observability/src/main/java/io/grpc/observability/LoggingChannelProvider.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2022 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.observability;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.InternalManagedChannelProvider;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ManagedChannelProvider;
+import io.grpc.ManagedChannelRegistry;
+import io.grpc.observability.interceptors.InternalLoggingChannelInterceptor;
+
+/** A channel provider that injects logging interceptor. */
+final class LoggingChannelProvider extends ManagedChannelProvider {
+ private final ManagedChannelProvider prevProvider;
+ private final InternalLoggingChannelInterceptor.Factory clientInterceptorFactory;
+
+ private static LoggingChannelProvider instance;
+
+ private LoggingChannelProvider(InternalLoggingChannelInterceptor.Factory factory) {
+ prevProvider = ManagedChannelProvider.provider();
+ clientInterceptorFactory = factory;
+ }
+
+ static synchronized void init(InternalLoggingChannelInterceptor.Factory factory) {
+ if (instance != null) {
+ throw new IllegalStateException("LoggingChannelProvider already initialized!");
+ }
+ instance = new LoggingChannelProvider(factory);
+ ManagedChannelRegistry.getDefaultRegistry().register(instance);
+ }
+
+ static synchronized void finish() {
+ if (instance == null) {
+ throw new IllegalStateException("LoggingChannelProvider not initialized!");
+ }
+ ManagedChannelRegistry.getDefaultRegistry().deregister(instance);
+ instance = null;
+ }
+
+ @Override
+ protected boolean isAvailable() {
+ return true;
+ }
+
+ @Override
+ protected int priority() {
+ return 6;
+ }
+
+ private ManagedChannelBuilder addInterceptor(ManagedChannelBuilder builder) {
+ return builder.intercept(clientInterceptorFactory.create());
+ }
+
+ @Override
+ protected ManagedChannelBuilder builderForAddress(String name, int port) {
+ return addInterceptor(
+ InternalManagedChannelProvider.builderForAddress(prevProvider, name, port));
+ }
+
+ @Override
+ protected ManagedChannelBuilder builderForTarget(String target) {
+ return addInterceptor(InternalManagedChannelProvider.builderForTarget(prevProvider, target));
+ }
+
+ @Override
+ protected NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds) {
+ NewChannelBuilderResult result = InternalManagedChannelProvider.newChannelBuilder(prevProvider,
+ target, creds);
+ ManagedChannelBuilder builder = result.getChannelBuilder();
+ if (builder != null) {
+ return NewChannelBuilderResult.channelBuilder(
+ addInterceptor(builder));
+ }
+ checkNotNull(result.getError(), "Expected error to be set!");
+ return result;
+ }
+}
diff --git a/observability/src/main/java/io/grpc/observability/LoggingServerProvider.java b/observability/src/main/java/io/grpc/observability/LoggingServerProvider.java
new file mode 100644
index 00000000000..5277bcf572b
--- /dev/null
+++ b/observability/src/main/java/io/grpc/observability/LoggingServerProvider.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2022 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.observability;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.InternalServerProvider;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerProvider;
+import io.grpc.ServerRegistry;
+import io.grpc.observability.interceptors.InternalLoggingServerInterceptor;
+
+/** A server provider that injects the logging interceptor. */
+final class LoggingServerProvider extends ServerProvider {
+ private final ServerProvider prevProvider;
+ private final InternalLoggingServerInterceptor.Factory serverInterceptorFactory;
+
+ private static LoggingServerProvider instance;
+
+ private LoggingServerProvider(InternalLoggingServerInterceptor.Factory factory) {
+ prevProvider = ServerProvider.provider();
+ serverInterceptorFactory = factory;
+ }
+
+ static synchronized void init(InternalLoggingServerInterceptor.Factory factory) {
+ if (instance != null) {
+ throw new IllegalStateException("LoggingServerProvider already initialized!");
+ }
+ instance = new LoggingServerProvider(factory);
+ ServerRegistry.getDefaultRegistry().register(instance);
+ }
+
+ static synchronized void finish() {
+ if (instance == null) {
+ throw new IllegalStateException("LoggingServerProvider not initialized!");
+ }
+ ServerRegistry.getDefaultRegistry().deregister(instance);
+ instance = null;
+ }
+
+ @Override
+ protected boolean isAvailable() {
+ return true;
+ }
+
+ @Override
+ protected int priority() {
+ return 6;
+ }
+
+ private ServerBuilder addInterceptor(ServerBuilder builder) {
+ return builder.intercept(serverInterceptorFactory.create());
+ }
+
+ @Override
+ protected ServerBuilder builderForPort(int port) {
+ return addInterceptor(InternalServerProvider.builderForPort(prevProvider, port));
+ }
+
+ @Override
+ protected NewServerBuilderResult newServerBuilderForPort(int port, ServerCredentials creds) {
+ ServerProvider.NewServerBuilderResult result = InternalServerProvider.newServerBuilderForPort(
+ prevProvider, port,
+ creds);
+ ServerBuilder builder = result.getServerBuilder();
+ if (builder != null) {
+ return ServerProvider.NewServerBuilderResult.serverBuilder(
+ addInterceptor(builder));
+ }
+ checkNotNull(result.getError(), "Expected error to be set!");
+ return result;
+ }
+}
diff --git a/observability/src/main/java/io/grpc/observability/Observability.java b/observability/src/main/java/io/grpc/observability/Observability.java
new file mode 100644
index 00000000000..a7a6b04ad07
--- /dev/null
+++ b/observability/src/main/java/io/grpc/observability/Observability.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 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.observability;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.ManagedChannelProvider.ProviderNotFoundException;
+import io.grpc.observability.interceptors.InternalLoggingChannelInterceptor;
+import io.grpc.observability.interceptors.InternalLoggingServerInterceptor;
+
+/** The main class for gRPC Observability features. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8869")
+public final class Observability {
+ private static boolean initialized = false;
+
+ /**
+ * Initialize grpc-observability.
+ *
+ * @throws ProviderNotFoundException if no underlying channel/server provider is available.
+ */
+ public static synchronized void grpcInit() {
+ if (initialized) {
+ throw new IllegalStateException("Observability already initialized!");
+ }
+ LoggingChannelProvider.init(new InternalLoggingChannelInterceptor.FactoryImpl());
+ LoggingServerProvider.init(new InternalLoggingServerInterceptor.FactoryImpl());
+ // TODO(sanjaypujare): initialize customTags map
+ initialized = true;
+ }
+
+ /** Un-initialize or finish grpc-observability. */
+ public static synchronized void grpcFinish() {
+ if (!initialized) {
+ throw new IllegalStateException("Observability not initialized!");
+ }
+ LoggingChannelProvider.finish();
+ LoggingServerProvider.finish();
+ // TODO(sanjaypujare): finish customTags map
+ initialized = false;
+ }
+
+ private Observability() {
+ }
+}
diff --git a/observability/src/main/java/io/grpc/observability/interceptors/InternalLoggingChannelInterceptor.java b/observability/src/main/java/io/grpc/observability/interceptors/InternalLoggingChannelInterceptor.java
new file mode 100644
index 00000000000..3e535de3816
--- /dev/null
+++ b/observability/src/main/java/io/grpc/observability/interceptors/InternalLoggingChannelInterceptor.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2022 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.observability.interceptors;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Internal;
+import io.grpc.MethodDescriptor;
+
+/** A logging interceptor for {@code LoggingChannelProvider}. */
+@Internal
+public final class InternalLoggingChannelInterceptor implements ClientInterceptor {
+
+ public interface Factory {
+ ClientInterceptor create();
+ }
+
+ public static class FactoryImpl implements Factory {
+
+ @Override
+ public ClientInterceptor create() {
+ return new InternalLoggingChannelInterceptor();
+ }
+ }
+
+ @Override
+ public ClientCall interceptCall(MethodDescriptor method,
+ CallOptions callOptions, Channel next) {
+ // TODO(dnvindhya) implement the interceptor
+ return null;
+ }
+}
diff --git a/observability/src/main/java/io/grpc/observability/interceptors/InternalLoggingServerInterceptor.java b/observability/src/main/java/io/grpc/observability/interceptors/InternalLoggingServerInterceptor.java
new file mode 100644
index 00000000000..17385653121
--- /dev/null
+++ b/observability/src/main/java/io/grpc/observability/interceptors/InternalLoggingServerInterceptor.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2022 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.observability.interceptors;
+
+import io.grpc.Internal;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+
+/** A logging interceptor for {@code LoggingServerProvider}. */
+@Internal
+public final class InternalLoggingServerInterceptor implements ServerInterceptor {
+
+ public interface Factory {
+ ServerInterceptor create();
+ }
+
+ public static class FactoryImpl implements Factory {
+
+ @Override
+ public ServerInterceptor create() {
+ return new InternalLoggingServerInterceptor();
+ }
+ }
+
+ @Override
+ public ServerCall.Listener interceptCall(ServerCall call,
+ Metadata headers, ServerCallHandler next) {
+ // TODO(dnvindhya) implement the interceptor
+ return null;
+ }
+}
diff --git a/observability/src/main/java/io/grpc/observability/logging/CloudLoggingHandler.java b/observability/src/main/java/io/grpc/observability/logging/CloudLoggingHandler.java
new file mode 100644
index 00000000000..f325b9d8383
--- /dev/null
+++ b/observability/src/main/java/io/grpc/observability/logging/CloudLoggingHandler.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2022 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.observability.logging;
+
+import com.google.cloud.MonitoredResource;
+import com.google.cloud.logging.LogEntry;
+import com.google.cloud.logging.Logging;
+import com.google.cloud.logging.LoggingOptions;
+import com.google.cloud.logging.Payload.JsonPayload;
+import com.google.cloud.logging.Severity;
+import com.google.common.base.Strings;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.util.JsonFormat;
+import io.grpc.Internal;
+import io.grpc.internal.JsonParser;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+/**
+ * Custom logging handler that outputs logs generated using {@link java.util.logging.Logger} to
+ * Cloud Logging.
+ */
+// TODO(vindhyan): replace custom JUL handler with internal sink implementation to eliminate
+// JUL dependency
+@Internal
+public class CloudLoggingHandler extends Handler {
+
+ private static final String DEFAULT_LOG_NAME = "grpc-observability";
+ private static final Level DEFAULT_LOG_LEVEL = Level.ALL;
+
+ private final LoggingOptions loggingOptions;
+ private final Logging loggingClient;
+ private final Level baseLevel;
+ private final String cloudLogName;
+
+ /**
+ * Creates a custom logging handler that publishes message to Cloud logging. Default log level is
+ * set to Level.FINEST if level is not passed.
+ */
+ public CloudLoggingHandler() {
+ this(DEFAULT_LOG_LEVEL, null, null);
+ }
+
+ /**
+ * Creates a custom logging handler that publishes message to Cloud logging.
+ *
+ * @param level set the level for which message levels will be logged by the custom logger
+ */
+ public CloudLoggingHandler(Level level) {
+ this(level, null, null);
+ }
+
+ /**
+ * Creates a custom logging handler that publishes message to Cloud logging.
+ *
+ * @param level set the level for which message levels will be logged by the custom logger
+ * @param logName the name of the log to which log entries are written
+ */
+ public CloudLoggingHandler(Level level, String logName) {
+ this(level, logName, null);
+ }
+
+ /**
+ * Creates a custom logging handler that publishes message to Cloud logging.
+ *
+ * @param level set the level for which message levels will be logged by the custom logger
+ * @param logName the name of the log to which log entries are written
+ * @param destinationProjectId the value of cloud project id to which logs are sent to by the
+ * custom logger
+ */
+ public CloudLoggingHandler(Level level, String logName, String destinationProjectId) {
+ baseLevel =
+ (level != null) ? (level.equals(DEFAULT_LOG_LEVEL) ? Level.FINEST : level) : Level.FINEST;
+ setLevel(baseLevel);
+ cloudLogName = logName != null ? logName : DEFAULT_LOG_NAME;
+
+ // TODO(dnvindhya) read the value from config instead of taking it as an argument
+ if (Strings.isNullOrEmpty(destinationProjectId)) {
+ loggingOptions = LoggingOptions.getDefaultInstance();
+ } else {
+ loggingOptions = LoggingOptions.newBuilder().setProjectId(destinationProjectId).build();
+ }
+ loggingClient = loggingOptions.getService();
+ }
+
+ @Override
+ public void publish(LogRecord record) {
+ if (!(record instanceof LogRecordExtension)) {
+ throw new IllegalArgumentException("Expected record of type LogRecordExtension");
+ }
+ Level logLevel = record.getLevel();
+ GrpcLogRecord protoRecord = ((LogRecordExtension) record).getGrpcLogRecord();
+ writeLog(protoRecord, logLevel);
+ }
+
+ private void writeLog(GrpcLogRecord logProto, Level logLevel) {
+ if (loggingClient == null) {
+ throw new IllegalStateException("Logging client not initialized");
+ }
+ try {
+ Severity cloudLogLevel = getCloudLoggingLevel(logLevel);
+ Map mapPayload = protoToMapConverter(logProto);
+
+ // TODO(vindhyan): make sure all (int, long) values are not displayed as double
+ LogEntry grpcLogEntry =
+ LogEntry.newBuilder(JsonPayload.of(mapPayload))
+ .setSeverity(cloudLogLevel)
+ .setLogName(cloudLogName)
+ .setResource(MonitoredResource.newBuilder("global").build())
+ .build();
+ loggingClient.write(Collections.singleton(grpcLogEntry));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private Map protoToMapConverter(GrpcLogRecord logProto)
+ throws InvalidProtocolBufferException, IOException {
+ JsonFormat.Printer printer = JsonFormat.printer().preservingProtoFieldNames();
+ String recordJson = printer.print(logProto);
+ return (Map) JsonParser.parse(recordJson);
+ }
+
+ @Override
+ public void flush() {
+ if (loggingClient == null) {
+ throw new IllegalStateException("Logging client not initialized");
+ }
+ loggingClient.flush();
+ }
+
+ @Override
+ public synchronized void close() throws SecurityException {
+ if (loggingClient == null) {
+ throw new IllegalStateException("Logging client not initialized");
+ }
+ try {
+ loggingClient.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private Severity getCloudLoggingLevel(Level recordLevel) {
+ switch (recordLevel.intValue()) {
+ case 300: // FINEST
+ case 400: // FINER
+ case 500: // FINE
+ return Severity.DEBUG;
+ case 700: // CONFIG
+ case 800: // INFO
+ return Severity.INFO;
+ case 900: // WARNING
+ return Severity.WARNING;
+ case 1000: // SEVERE
+ return Severity.ERROR;
+ default:
+ return Severity.DEFAULT;
+ }
+ }
+}
diff --git a/observability/src/main/java/io/grpc/observability/logging/LogRecordExtension.java b/observability/src/main/java/io/grpc/observability/logging/LogRecordExtension.java
new file mode 100644
index 00000000000..a1220659302
--- /dev/null
+++ b/observability/src/main/java/io/grpc/observability/logging/LogRecordExtension.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2022 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.observability.logging;
+
+import io.grpc.Internal;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+/**
+ * An extension of java.util.logging.LogRecord which includes gRPC observability logging specific
+ * fields.
+ */
+@Internal
+public final class LogRecordExtension extends LogRecord {
+
+ private final GrpcLogRecord grpcLogRecord;
+
+ public LogRecordExtension(Level recordLevel, GrpcLogRecord record) {
+ super(recordLevel, null);
+ this.grpcLogRecord = record;
+ }
+
+ public GrpcLogRecord getGrpcLogRecord() {
+ return grpcLogRecord;
+ }
+
+ // Adding a serial version UID since base class i.e LogRecord is Serializable
+ private static final long serialVersionUID = 1L;
+}
diff --git a/observability/src/main/proto/grpc/observabilitylog/v1/observabilitylog.proto b/observability/src/main/proto/grpc/observabilitylog/v1/observabilitylog.proto
new file mode 100644
index 00000000000..d2e72329cde
--- /dev/null
+++ b/observability/src/main/proto/grpc/observabilitylog/v1/observabilitylog.proto
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2022 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.
+ */
+
+syntax = "proto3";
+
+package grpc.observabilitylog.v1;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.observabilitylog.v1";
+option java_outer_classname = "ObservabilityLogProto";
+
+message GrpcLogRecord {
+ // List of event types
+ enum EventType {
+ GRPC_CALL_UNKNOWN = 0;
+ // Header sent from client to server
+ GRPC_CALL_REQUEST_HEADER = 1;
+ // Header sent from server to client
+ GRPC_CALL_RESPONSE_HEADER = 2;
+ // Message sent from client to server
+ GRPC_CALL_REQUEST_MESSAGE = 3;
+ // Message sent from server to client
+ GRPC_CALL_RESPONSE_MESSAGE = 4;
+ // Trailer indicates the end of the gRPC call
+ GRPC_CALL_TRAILER = 5;
+ // A signal that client is done sending
+ GRPC_CALL_HALF_CLOSE = 6;
+ // A signal that the rpc is canceled
+ GRPC_CALL_CANCEL = 7;
+ }
+ // The entity that generates the log entry
+ enum EventLogger {
+ LOGGER_UNKNOWN = 0;
+ LOGGER_CLIENT = 1;
+ LOGGER_SERVER = 2;
+ }
+ // The log severity level of the log entry
+ enum LogLevel {
+ LOG_LEVEL_UNKNOWN = 0;
+ LOG_LEVEL_TRACE = 1;
+ LOG_LEVEL_DEBUG = 2;
+ LOG_LEVEL_INFO = 3;
+ LOG_LEVEL_WARN = 4;
+ LOG_LEVEL_ERROR = 5;
+ LOG_LEVEL_CRITICAL = 6;
+ }
+
+ // The timestamp of the log event
+ google.protobuf.Timestamp timestamp = 1;
+
+ // Uniquely identifies a call. The value must not be 0 in order to disambiguate
+ // from an unset value.
+ // Each call may have several log entries. They will all have the same rpc_id.
+ // Nothing is guaranteed about their value other than they are unique across
+ // different RPCs in the same gRPC process.
+ uint64 rpc_id = 2;
+
+ EventType event_type = 3; // one of the above EventType enum
+ EventLogger event_logger = 4; // one of the above EventLogger enum
+
+ // the name of the service
+ string service_name = 5;
+ // the name of the RPC method
+ string method_name = 6;
+
+ LogLevel log_level = 7; // one of the above LogLevel enum
+
+ // Peer address information. On client side, peer is logged on server
+ // header event or trailer event (if trailer-only). On server side, peer
+ // is always logged on the client header event.
+ Address peer_address = 8;
+
+ // the RPC timeout value
+ google.protobuf.Duration timeout = 11;
+
+ // A single process may be used to run multiple virtual servers with
+ // different identities.
+ // The authority is the name of such a server identify. It is typically a
+ // portion of the URI in the form of or :.
+ string authority = 12;
+
+ // Size of the message or metadata, depending on the event type,
+ // regardless of whether the full message or metadata is being logged
+ // (i.e. could be truncated or omitted).
+ uint32 payload_size = 13;
+
+ // true if message or metadata field is either truncated or omitted due
+ // to config options
+ bool payload_truncated = 14;
+
+ // Used by header event or trailer event
+ Metadata metadata = 15;
+
+ // The entry sequence ID for this call. The first message has a value of 1,
+ // to disambiguate from an unset value. The purpose of this field is to
+ // detect missing entries in environments where durability or ordering is
+ // not guaranteed.
+ uint64 sequence_id = 16;
+
+ // Used by message event
+ bytes message = 17;
+
+ // The gRPC status code
+ uint32 status_code = 18;
+
+ // The gRPC status message
+ string status_message = 19;
+
+ // The value of the grpc-status-details-bin metadata key, if any.
+ // This is always an encoded google.rpc.Status message
+ bytes status_details = 20;
+
+ // Attributes of the environment generating log record. The purpose of this
+ // field is to identify the source environment.
+ EnvironmentTags env_tags = 21;
+
+ // A list of non-gRPC custom values specified by the application
+ repeated CustomTags custom_tags = 22;
+
+ // A list of metadata pairs
+ message Metadata {
+ repeated MetadataEntry entry = 1;
+ }
+
+ // One metadata key value pair
+ message MetadataEntry {
+ string key = 1;
+ bytes value = 2;
+ }
+
+ // Address information
+ message Address {
+ enum Type {
+ TYPE_UNKNOWN = 0;
+ TYPE_IPV4 = 1; // in 1.2.3.4 form
+ TYPE_IPV6 = 2; // IPv6 canonical form (RFC5952 section 4)
+ TYPE_UNIX = 3; // UDS string
+ }
+ Type type = 1;
+ string address = 2;
+ // only for TYPE_IPV4 and TYPE_IPV6
+ uint32 ip_port = 3;
+ }
+
+ // Source Environment information
+ message EnvironmentTags {
+ string gcp_project_id = 1;
+ string gcp_numeric_project_id = 2;
+ string gce_instance_id = 3;
+ string gce_instance_hostname = 4;
+ string gce_instance_zone = 5;
+ string gke_cluster_uid = 6;
+ string gke_cluster_name = 7;
+ string gke_cluster_location = 8;
+ }
+
+ // Custom key value pair
+ message CustomTags {
+ string key = 1;
+ string value = 2;
+ }
+}
diff --git a/observability/src/test/java/io/grpc/observability/LoggingChannelProviderTest.java b/observability/src/test/java/io/grpc/observability/LoggingChannelProviderTest.java
new file mode 100644
index 00000000000..639bcbc6d0d
--- /dev/null
+++ b/observability/src/test/java/io/grpc/observability/LoggingChannelProviderTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2022 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.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ManagedChannelProvider;
+import io.grpc.MethodDescriptor;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.observability.interceptors.InternalLoggingChannelInterceptor;
+import io.grpc.testing.TestMethodDescriptors;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class LoggingChannelProviderTest {
+ @Rule
+ public final MockitoRule mocks = MockitoJUnit.rule();
+
+ private final MethodDescriptor method = TestMethodDescriptors.voidMethod();
+
+ @Test
+ public void initTwiceCausesException() {
+ ManagedChannelProvider prevProvider = ManagedChannelProvider.provider();
+ assertThat(prevProvider).isNotInstanceOf(LoggingChannelProvider.class);
+ LoggingChannelProvider.init(new InternalLoggingChannelInterceptor.FactoryImpl());
+ assertThat(ManagedChannelProvider.provider()).isInstanceOf(LoggingChannelProvider.class);
+ try {
+ LoggingChannelProvider.init(new InternalLoggingChannelInterceptor.FactoryImpl());
+ fail("should have failed for calling init() again");
+ } catch (IllegalStateException e) {
+ assertThat(e).hasMessageThat().contains("LoggingChannelProvider already initialized!");
+ }
+ LoggingChannelProvider.finish();
+ assertThat(ManagedChannelProvider.provider()).isSameInstanceAs(prevProvider);
+ }
+
+ @Test
+ public void forTarget_interceptorCalled() {
+ ClientInterceptor interceptor = mock(ClientInterceptor.class,
+ delegatesTo(new NoopInterceptor()));
+ InternalLoggingChannelInterceptor.Factory factory = mock(
+ InternalLoggingChannelInterceptor.Factory.class);
+ when(factory.create()).thenReturn(interceptor);
+ LoggingChannelProvider.init(factory);
+ ManagedChannelBuilder builder = ManagedChannelBuilder.forTarget("localhost");
+ ManagedChannel channel = builder.build();
+ CallOptions callOptions = CallOptions.DEFAULT;
+
+ ClientCall unused = channel.newCall(method, callOptions);
+ verify(interceptor)
+ .interceptCall(same(method), same(callOptions), ArgumentMatchers.any());
+ channel.shutdownNow();
+ LoggingChannelProvider.finish();
+ }
+
+ @Test
+ public void forAddress_interceptorCalled() {
+ ClientInterceptor interceptor = mock(ClientInterceptor.class,
+ delegatesTo(new NoopInterceptor()));
+ InternalLoggingChannelInterceptor.Factory factory = mock(
+ InternalLoggingChannelInterceptor.Factory.class);
+ when(factory.create()).thenReturn(interceptor);
+ LoggingChannelProvider.init(factory);
+ ManagedChannelBuilder builder = ManagedChannelBuilder.forAddress("localhost", 80);
+ ManagedChannel channel = builder.build();
+ CallOptions callOptions = CallOptions.DEFAULT;
+
+ ClientCall unused = channel.newCall(method, callOptions);
+ verify(interceptor)
+ .interceptCall(same(method), same(callOptions), ArgumentMatchers.any());
+ channel.shutdownNow();
+ LoggingChannelProvider.finish();
+ }
+
+ @Test
+ public void newChannelBuilder_interceptorCalled() {
+ ClientInterceptor interceptor = mock(ClientInterceptor.class,
+ delegatesTo(new NoopInterceptor()));
+ InternalLoggingChannelInterceptor.Factory factory = mock(
+ InternalLoggingChannelInterceptor.Factory.class);
+ when(factory.create()).thenReturn(interceptor);
+ LoggingChannelProvider.init(factory);
+ ManagedChannelBuilder builder = Grpc.newChannelBuilder("localhost",
+ TlsChannelCredentials.create());
+ ManagedChannel channel = builder.build();
+ CallOptions callOptions = CallOptions.DEFAULT;
+
+ ClientCall unused = channel.newCall(method, callOptions);
+ verify(interceptor)
+ .interceptCall(same(method), same(callOptions), ArgumentMatchers.any());
+ channel.shutdownNow();
+ LoggingChannelProvider.finish();
+ }
+
+ private static class NoopInterceptor implements ClientInterceptor {
+ @Override
+ public ClientCall interceptCall(MethodDescriptor method,
+ CallOptions callOptions, Channel next) {
+ return next.newCall(method, callOptions);
+ }
+ }
+}
diff --git a/observability/src/test/java/io/grpc/observability/LoggingServerProviderTest.java b/observability/src/test/java/io/grpc/observability/LoggingServerProviderTest.java
new file mode 100644
index 00000000000..fd6b60b4738
--- /dev/null
+++ b/observability/src/test/java/io/grpc/observability/LoggingServerProviderTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2022 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.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerProvider;
+import io.grpc.observability.interceptors.InternalLoggingServerInterceptor;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import java.io.IOException;
+import java.util.function.Supplier;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
+
+@RunWith(JUnit4.class)
+public class LoggingServerProviderTest {
+ @Rule public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+ @Test
+ public void initTwiceCausesException() {
+ ServerProvider prevProvider = ServerProvider.provider();
+ assertThat(prevProvider).isNotInstanceOf(LoggingServerProvider.class);
+ LoggingServerProvider.init(new InternalLoggingServerInterceptor.FactoryImpl());
+ assertThat(ServerProvider.provider()).isInstanceOf(ServerProvider.class);
+ try {
+ LoggingServerProvider.init(new InternalLoggingServerInterceptor.FactoryImpl());
+ fail("should have failed for calling init() again");
+ } catch (IllegalStateException e) {
+ assertThat(e).hasMessageThat().contains("LoggingServerProvider already initialized!");
+ }
+ LoggingServerProvider.finish();
+ assertThat(ServerProvider.provider()).isSameInstanceAs(prevProvider);
+ }
+
+ @Test
+ public void forPort_interceptorCalled() throws IOException {
+ serverBuilder_interceptorCalled(() -> ServerBuilder.forPort(0));
+ }
+
+ @Test
+ public void newServerBuilder_interceptorCalled() throws IOException {
+ serverBuilder_interceptorCalled(
+ () -> Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create()));
+ }
+
+ @SuppressWarnings("unchecked")
+ private void serverBuilder_interceptorCalled(Supplier> serverBuilderSupplier)
+ throws IOException {
+ ServerInterceptor interceptor =
+ mock(ServerInterceptor.class, delegatesTo(new NoopInterceptor()));
+ InternalLoggingServerInterceptor.Factory factory = mock(
+ InternalLoggingServerInterceptor.Factory.class);
+ when(factory.create()).thenReturn(interceptor);
+ LoggingServerProvider.init(factory);
+ Server server = serverBuilderSupplier.get().addService(new SimpleServiceImpl()).build().start();
+ int port = cleanupRule.register(server).getPort();
+ ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", port).usePlaintext()
+ .build();
+ SimpleServiceGrpc.SimpleServiceBlockingStub stub = SimpleServiceGrpc.newBlockingStub(
+ cleanupRule.register(channel));
+ assertThat(unaryRpc("buddy", stub)).isEqualTo("Hello buddy");
+ verify(interceptor).interceptCall(any(ServerCall.class), any(Metadata.class), anyCallHandler());
+ LoggingServerProvider.finish();
+ }
+
+ private ServerCallHandler anyCallHandler() {
+ return ArgumentMatchers.any();
+ }
+
+ private static String unaryRpc(
+ String requestMessage, SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub) {
+ SimpleRequest request = SimpleRequest.newBuilder().setRequestMessage(requestMessage).build();
+ SimpleResponse response = blockingStub.unaryRpc(request);
+ return response.getResponseMessage();
+ }
+
+ private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+
+ @Override
+ public void unaryRpc(SimpleRequest req, StreamObserver responseObserver) {
+ SimpleResponse response =
+ SimpleResponse.newBuilder()
+ .setResponseMessage("Hello " + req.getRequestMessage())
+ .build();
+ responseObserver.onNext(response);
+ responseObserver.onCompleted();
+ }
+ }
+
+ private static class NoopInterceptor implements ServerInterceptor {
+ @Override
+ public ServerCall.Listener interceptCall(
+ ServerCall call,
+ Metadata headers,
+ ServerCallHandler next) {
+ return next.startCall(call, headers);
+ }
+ }
+}
diff --git a/observability/src/test/java/io/grpc/observability/ObservabilityTest.java b/observability/src/test/java/io/grpc/observability/ObservabilityTest.java
new file mode 100644
index 00000000000..6c71a0e2640
--- /dev/null
+++ b/observability/src/test/java/io/grpc/observability/ObservabilityTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2022 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.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ObservabilityTest {
+
+ @Test
+ public void initFinish() {
+ Observability.grpcInit();
+ try {
+ Observability.grpcInit();
+ fail("should have failed for calling grpcInit() again");
+ } catch (IllegalStateException e) {
+ assertThat(e).hasMessageThat().contains("Observability already initialized!");
+ }
+ Observability.grpcFinish();
+ try {
+ Observability.grpcFinish();
+ fail("should have failed for calling grpcFinit() on uninitialized");
+ } catch (IllegalStateException e) {
+ assertThat(e).hasMessageThat().contains("Observability not initialized!");
+ }
+ }
+}
diff --git a/okhttp/build.gradle b/okhttp/build.gradle
index 3271118feda..999f21e7c10 100644
--- a/okhttp/build.gradle
+++ b/okhttp/build.gradle
@@ -22,7 +22,7 @@ dependencies {
project(':grpc-testing'),
project(':grpc-netty')
signature "org.codehaus.mojo.signature:java17:1.0@signature"
- signature "net.sf.androidscents.signature:android-api-level-19:4.4.2_r4@signature"
+ signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
}
project.sourceSets {
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
index 121093716db..cf7cae19d8a 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
@@ -419,7 +419,7 @@ public OkHttpClientStream newStream(
void streamReadyToStart(OkHttpClientStream clientStream) {
if (goAwayStatus != null) {
clientStream.transportState().transportReportStatus(
- goAwayStatus, RpcProgress.REFUSED, true, new Metadata());
+ goAwayStatus, RpcProgress.MISCARRIED, true, new Metadata());
} else if (streams.size() >= maxConcurrentStreams) {
pendingStreams.add(clientStream);
setInUse(clientStream);
@@ -811,7 +811,10 @@ public void shutdownNow(Status reason) {
}
for (OkHttpClientStream stream : pendingStreams) {
- stream.transportState().transportReportStatus(reason, true, new Metadata());
+ // in cases such as the connection fails to ACK keep-alive, pending streams should have a
+ // chance to retry and be routed to another connection.
+ stream.transportState().transportReportStatus(
+ reason, RpcProgress.MISCARRIED, true, new Metadata());
maybeClearInUse(stream);
}
pendingStreams.clear();
@@ -894,7 +897,7 @@ private void startGoAway(int lastKnownStreamId, ErrorCode errorCode, Status stat
for (OkHttpClientStream stream : pendingStreams) {
stream.transportState().transportReportStatus(
- status, RpcProgress.REFUSED, true, new Metadata());
+ status, RpcProgress.MISCARRIED, true, new Metadata());
maybeClearInUse(stream);
}
pendingStreams.clear();
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
index 46a49463e5f..99a9159eab0 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
@@ -42,7 +42,7 @@
import io.grpc.okhttp.internal.framed.Header;
import java.io.ByteArrayInputStream;
import java.io.IOException;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.Before;
@@ -243,7 +243,7 @@ public void getUnaryRequest() throws IOException {
eq(false), eq(false), eq(3), eq(0), headersCaptor.capture());
verify(transport, times(0)).streamReadyToStart(isA(OkHttpClientStream.class));
- byte[] msg = "request".getBytes(StandardCharsets.UTF_8);
+ byte[] msg = "request".getBytes(Charset.forName("UTF-8"));
stream.writeMessage(new ByteArrayInputStream(msg));
stream.halfClose();
verify(transport).streamReadyToStart(eq(stream));
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
index b70b832a797..1628df4d3c3 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
@@ -18,6 +18,7 @@
import static com.google.common.base.Charsets.UTF_8;
import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.MISCARRIED;
import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
import static io.grpc.internal.ClientStreamListener.RpcProgress.REFUSED;
import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
@@ -2080,7 +2081,7 @@ public void goAway_streamListenerRpcProgress() throws Exception {
listener3.waitUntilStreamClosed();
assertNull(listener1.rpcProgress);
assertEquals(REFUSED, listener2.rpcProgress);
- assertEquals(REFUSED, listener3.rpcProgress);
+ assertEquals(MISCARRIED, listener3.rpcProgress);
assertEquals(1, activeStreamCount());
assertContainStream(DEFAULT_START_STREAM_ID);
@@ -2133,6 +2134,39 @@ public void reset_streamListenerRpcProgress() throws Exception {
shutdownAndVerify();
}
+ @Test
+ public void shutdownNow_streamListenerRpcProgress() throws Exception {
+ initTransport();
+ setMaxConcurrentStreams(2);
+ MockStreamListener listener1 = new MockStreamListener();
+ MockStreamListener listener2 = new MockStreamListener();
+ MockStreamListener listener3 = new MockStreamListener();
+ OkHttpClientStream stream1 =
+ clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+ stream1.start(listener1);
+ OkHttpClientStream stream2 =
+ clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+ stream2.start(listener2);
+ OkHttpClientStream stream3 =
+ clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+ stream3.start(listener3);
+ waitForStreamPending(1);
+
+ assertEquals(2, activeStreamCount());
+ assertContainStream(DEFAULT_START_STREAM_ID);
+ assertContainStream(DEFAULT_START_STREAM_ID + 2);
+
+ clientTransport.shutdownNow(Status.INTERNAL);
+
+ listener1.waitUntilStreamClosed();
+ listener2.waitUntilStreamClosed();
+ listener3.waitUntilStreamClosed();
+
+ assertEquals(PROCESSED, listener1.rpcProgress);
+ assertEquals(PROCESSED, listener2.rpcProgress);
+ assertEquals(MISCARRIED, listener3.rpcProgress);
+ }
+
private int activeStreamCount() {
return clientTransport.getActiveStreams().length;
}
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Util.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Util.java
index a961c605656..556d849c705 100644
--- a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Util.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Util.java
@@ -27,7 +27,6 @@
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
@@ -48,7 +47,7 @@ public final class Util {
public static final String[] EMPTY_STRING_ARRAY = new String[0];
/** A cheap and type-safe constant for the UTF-8 Charset. */
- public static final Charset UTF_8 = StandardCharsets.UTF_8;
+ public static final Charset UTF_8 = Charset.forName("UTF-8");
private Util() {
}
diff --git a/protobuf-lite/build.gradle b/protobuf-lite/build.gradle
index 75cca43f0e6..7b58309c414 100644
--- a/protobuf-lite/build.gradle
+++ b/protobuf-lite/build.gradle
@@ -18,7 +18,7 @@ dependencies {
testImplementation project(':grpc-core')
signature "org.codehaus.mojo.signature:java17:1.0@signature"
- signature "net.sf.androidscents.signature:android-api-level-19:4.4.2_r4@signature"
+ signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
}
compileTestJava {
diff --git a/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java b/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java
index 7bd9f4b68e3..da388be0503 100644
--- a/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java
+++ b/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java
@@ -23,24 +23,19 @@
import com.google.common.base.Converter;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.grpc.ChannelLogger;
import io.grpc.ChannelLogger.ChannelLogLevel;
import io.grpc.ConnectivityState;
-import io.grpc.LoadBalancer;
import io.grpc.LoadBalancer.Helper;
import io.grpc.LoadBalancer.PickResult;
import io.grpc.LoadBalancer.PickSubchannelArgs;
import io.grpc.LoadBalancer.ResolvedAddresses;
import io.grpc.LoadBalancer.SubchannelPicker;
-import io.grpc.LoadBalancerProvider;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
-import io.grpc.NameResolver.ConfigOrError;
import io.grpc.Status;
import io.grpc.SynchronizationContext;
import io.grpc.SynchronizationContext.ScheduledHandle;
@@ -51,7 +46,6 @@
import io.grpc.lookup.v1.RouteLookupServiceGrpc.RouteLookupServiceStub;
import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
import io.grpc.rls.LbPolicyConfiguration.ChildLbStatusListener;
-import io.grpc.rls.LbPolicyConfiguration.ChildLoadBalancingPolicy;
import io.grpc.rls.LbPolicyConfiguration.ChildPolicyWrapper;
import io.grpc.rls.LbPolicyConfiguration.RefCountedChildPolicyWrapperFactory;
import io.grpc.rls.LruCache.EvictionListener;
@@ -87,13 +81,6 @@ final class CachingRlsLbClient {
private static final Converter
RESPONSE_CONVERTER = new RouteLookupResponseConverter().reverse();
- // System property to use direct path enabled OobChannel, by default direct path is enabled.
- private static final String RLS_ENABLE_OOB_CHANNEL_DIRECTPATH_PROPERTY =
- "io.grpc.rls.CachingRlsLbClient.enable_oobchannel_directpath";
- @VisibleForTesting
- static boolean enableOobChannelDirectPath =
- Boolean.parseBoolean(System.getProperty(RLS_ENABLE_OOB_CHANNEL_DIRECTPATH_PROPERTY, "false"));
-
// All cache status changes (pending, backoff, success) must be under this lock
private final Object lock = new Object();
// LRU cache based on access order (BACKOFF and actual data will be here)
@@ -128,17 +115,18 @@ private CachingRlsLbClient(Builder builder) {
synchronizationContext = helper.getSynchronizationContext();
lbPolicyConfig = checkNotNull(builder.lbPolicyConfig, "lbPolicyConfig");
RouteLookupConfig rlsConfig = lbPolicyConfig.getRouteLookupConfig();
- maxAgeNanos = rlsConfig.getMaxAgeInNanos();
- staleAgeNanos = rlsConfig.getStaleAgeInNanos();
- callTimeoutNanos = rlsConfig.getLookupServiceTimeoutInNanos();
+ maxAgeNanos = rlsConfig.maxAgeInNanos();
+ staleAgeNanos = rlsConfig.staleAgeInNanos();
+ callTimeoutNanos = rlsConfig.lookupServiceTimeoutInNanos();
timeProvider = checkNotNull(builder.timeProvider, "timeProvider");
throttler = checkNotNull(builder.throttler, "throttler");
linkedHashLruCache =
new RlsAsyncLruCache(
- rlsConfig.getCacheSizeBytes(),
+ rlsConfig.cacheSizeBytes(),
builder.evictionListener,
scheduledExecutorService,
- timeProvider);
+ timeProvider,
+ lock);
logger = helper.getChannelLogger();
String serverHost = null;
try {
@@ -159,16 +147,16 @@ private CachingRlsLbClient(Builder builder) {
// will be looked up differently than the backends; overrideAuthority(helper.getAuthority()) is
// called to impose the authority security restrictions.
ManagedChannelBuilder rlsChannelBuilder = helper.createResolvingOobChannelBuilder(
- rlsConfig.getLookupService(), helper.getUnsafeChannelCredentials());
+ rlsConfig.lookupService(), helper.getUnsafeChannelCredentials());
rlsChannelBuilder.overrideAuthority(helper.getAuthority());
- if (enableOobChannelDirectPath) {
- Map directPathServiceConfig =
- getDirectPathServiceConfig(rlsConfig.getLookupService());
+ Map routeLookupChannelServiceConfig =
+ lbPolicyConfig.getRouteLookupChannelServiceConfig();
+ if (routeLookupChannelServiceConfig != null) {
logger.log(
ChannelLogLevel.DEBUG,
- "RLS channel direct path enabled. RLS channel service config: {0}",
- directPathServiceConfig);
- rlsChannelBuilder.defaultServiceConfig(directPathServiceConfig);
+ "RLS channel service config: {0}",
+ routeLookupChannelServiceConfig);
+ rlsChannelBuilder.defaultServiceConfig(routeLookupChannelServiceConfig);
rlsChannelBuilder.disableServiceConfigLookUp();
}
rlsChannel = rlsChannelBuilder.build();
@@ -181,25 +169,12 @@ private CachingRlsLbClient(Builder builder) {
new ChildLoadBalancerHelperProvider(helper, new SubchannelStateManagerImpl(), rlsPicker);
refCountedChildPolicyWrapperFactory =
new RefCountedChildPolicyWrapperFactory(
- childLbHelperProvider, new BackoffRefreshListener());
+ lbPolicyConfig.getLoadBalancingPolicy(), childLbResolvedAddressFactory,
+ childLbHelperProvider,
+ new BackoffRefreshListener());
logger.log(ChannelLogLevel.DEBUG, "CachingRlsLbClient created");
}
- private static ImmutableMap getDirectPathServiceConfig(String serviceName) {
- ImmutableMap pickFirstStrategy =
- ImmutableMap.of("pick_first", ImmutableMap.of());
-
- ImmutableMap childPolicy =
- ImmutableMap.of(
- "childPolicy", ImmutableList.of(pickFirstStrategy),
- "serviceName", serviceName);
-
- ImmutableMap grpcLbPolicy =
- ImmutableMap.of("grpclb", childPolicy);
-
- return ImmutableMap.of("loadBalancingConfig", ImmutableList.of(grpcLbPolicy));
- }
-
@CheckReturnValue
private ListenableFuture asyncRlsCall(RouteLookupRequest request) {
final SettableFuture response = SettableFuture.create();
@@ -536,39 +511,17 @@ final class DataCacheEntry extends CacheEntry {
private final long staleTime;
private final ChildPolicyWrapper childPolicyWrapper;
+ // GuardedBy CachingRlsLbClient.lock
DataCacheEntry(RouteLookupRequest request, final RouteLookupResponse response) {
super(request);
this.response = checkNotNull(response, "response");
// TODO(creamsoup) fallback to other targets if first one is not available
childPolicyWrapper =
refCountedChildPolicyWrapperFactory
- .createOrGet(response.getTargets().get(0));
+ .createOrGet(response.targets().get(0));
long now = timeProvider.currentTimeNanos();
expireTime = now + maxAgeNanos;
staleTime = now + staleAgeNanos;
-
- if (childPolicyWrapper.getPicker() != null) {
- childPolicyWrapper.refreshState();
- } else {
- createChildLbPolicy();
- }
- }
-
- private void createChildLbPolicy() {
- ChildLoadBalancingPolicy childPolicy = lbPolicyConfig.getLoadBalancingPolicy();
- LoadBalancerProvider lbProvider = childPolicy.getEffectiveLbProvider();
- ConfigOrError lbConfig =
- lbProvider
- .parseLoadBalancingPolicyConfig(
- childPolicy.getEffectiveChildPolicy(childPolicyWrapper.getTarget()));
-
- LoadBalancer lb = lbProvider.newLoadBalancer(childPolicyWrapper.getHelper());
- logger.log(
- ChannelLogLevel.DEBUG,
- "RLS child lb created. config: {0}",
- lbConfig.getConfig());
- lb.handleResolvedAddresses(childLbResolvedAddressFactory.create(lbConfig.getConfig()));
- lb.requestConnection();
}
/**
@@ -623,7 +576,7 @@ String getHeaderData() {
int getSizeBytes() {
// size of strings and java object overhead, actual memory usage is more than this.
return
- (response.getTargets().get(0).length() + response.getHeaderData().length()) * 2 + 38 * 2;
+ (response.targets().get(0).length() + response.getHeaderData().length()) * 2 + 38 * 2;
}
@Override
@@ -637,7 +590,9 @@ boolean isStaled(long now) {
@Override
void cleanup() {
- refCountedChildPolicyWrapperFactory.release(childPolicyWrapper);
+ synchronized (lock) {
+ refCountedChildPolicyWrapperFactory.release(childPolicyWrapper);
+ }
}
@Override
@@ -856,14 +811,15 @@ private static final class RlsAsyncLruCache
RlsAsyncLruCache(long maxEstimatedSizeBytes,
@Nullable EvictionListener evictionListener,
- ScheduledExecutorService ses, TimeProvider timeProvider) {
+ ScheduledExecutorService ses, TimeProvider timeProvider, Object lock) {
super(
maxEstimatedSizeBytes,
new AutoCleaningEvictionListener(evictionListener),
1,
TimeUnit.MINUTES,
ses,
- timeProvider);
+ timeProvider,
+ lock);
}
@Override
@@ -924,20 +880,21 @@ final class RlsPicker extends SubchannelPicker {
@Override
public PickResult pickSubchannel(PickSubchannelArgs args) {
- String[] methodName = args.getMethodDescriptor().getFullMethodName().split("/", 2);
+ String serviceName = args.getMethodDescriptor().getServiceName();
+ String methodName = args.getMethodDescriptor().getBareMethodName();
RouteLookupRequest request =
- requestFactory.create(methodName[0], methodName[1], args.getHeaders());
+ requestFactory.create(serviceName, methodName, args.getHeaders());
final CachedRouteLookupResponse response = CachingRlsLbClient.this.get(request);
logger.log(ChannelLogLevel.DEBUG,
"Got route lookup cache entry for service={0}, method={1}, headers={2}:\n {3}",
- new Object[]{methodName[0], methodName[1], args.getHeaders(), response});
+ new Object[]{serviceName, methodName, args.getHeaders(), response});
if (response.getHeaderData() != null && !response.getHeaderData().isEmpty()) {
Metadata headers = args.getHeaders();
headers.discardAll(RLS_DATA_KEY);
headers.put(RLS_DATA_KEY, response.getHeaderData());
}
- String defaultTarget = lbPolicyConfig.getRouteLookupConfig().getDefaultTarget();
+ String defaultTarget = lbPolicyConfig.getRouteLookupConfig().defaultTarget();
boolean hasFallback = defaultTarget != null && !defaultTarget.isEmpty();
if (response.hasData()) {
ChildPolicyWrapper childPolicyWrapper = response.getChildPolicyWrapper();
@@ -977,7 +934,7 @@ private PickResult useFallback(PickSubchannelArgs args) {
}
private void startFallbackChildPolicy() {
- String defaultTarget = lbPolicyConfig.getRouteLookupConfig().getDefaultTarget();
+ String defaultTarget = lbPolicyConfig.getRouteLookupConfig().defaultTarget();
logger.log(ChannelLogLevel.DEBUG, "starting fallback to {0}", defaultTarget);
synchronized (lock) {
if (fallbackChildPolicyWrapper != null) {
@@ -985,27 +942,9 @@ private void startFallbackChildPolicy() {
}
fallbackChildPolicyWrapper = refCountedChildPolicyWrapperFactory.createOrGet(defaultTarget);
}
- LoadBalancerProvider lbProvider =
- lbPolicyConfig.getLoadBalancingPolicy().getEffectiveLbProvider();
- final LoadBalancer lb =
- lbProvider.newLoadBalancer(fallbackChildPolicyWrapper.getHelper());
- final ConfigOrError lbConfig =
- lbProvider
- .parseLoadBalancingPolicyConfig(
- lbPolicyConfig
- .getLoadBalancingPolicy()
- .getEffectiveChildPolicy(defaultTarget));
- helper.getSynchronizationContext().execute(
- new Runnable() {
- @Override
- public void run() {
- lb.handleResolvedAddresses(
- childLbResolvedAddressFactory.create(lbConfig.getConfig()));
- lb.requestConnection();
- }
- });
}
+ // GuardedBy CachingRlsLbClient.lock
void close() {
if (fallbackChildPolicyWrapper != null) {
refCountedChildPolicyWrapperFactory.release(fallbackChildPolicyWrapper);
@@ -1015,7 +954,7 @@ void close() {
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
- .add("target", lbPolicyConfig.getRouteLookupConfig().getLookupService())
+ .add("target", lbPolicyConfig.getRouteLookupConfig().lookupService())
.toString();
}
}
diff --git a/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java b/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
index f54e441ffe5..f40cde9fd81 100644
--- a/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
+++ b/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
@@ -22,12 +22,15 @@
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
+import io.grpc.ChannelLogger.ChannelLogLevel;
import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
import io.grpc.LoadBalancer.Helper;
import io.grpc.LoadBalancer.Subchannel;
import io.grpc.LoadBalancer.SubchannelPicker;
import io.grpc.LoadBalancerProvider;
import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
import io.grpc.internal.ObjectPool;
import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
import io.grpc.rls.RlsProtoData.RouteLookupConfig;
@@ -45,11 +48,15 @@
final class LbPolicyConfiguration {
private final RouteLookupConfig routeLookupConfig;
+ @Nullable
+ private final Map routeLookupChannelServiceConfig;
private final ChildLoadBalancingPolicy policy;
LbPolicyConfiguration(
- RouteLookupConfig routeLookupConfig, ChildLoadBalancingPolicy policy) {
+ RouteLookupConfig routeLookupConfig, @Nullable Map routeLookupChannelServiceConfig,
+ ChildLoadBalancingPolicy policy) {
this.routeLookupConfig = checkNotNull(routeLookupConfig, "routeLookupConfig");
+ this.routeLookupChannelServiceConfig = routeLookupChannelServiceConfig;
this.policy = checkNotNull(policy, "policy");
}
@@ -57,6 +64,11 @@ RouteLookupConfig getRouteLookupConfig() {
return routeLookupConfig;
}
+ @Nullable
+ Map getRouteLookupChannelServiceConfig() {
+ return routeLookupChannelServiceConfig;
+ }
+
ChildLoadBalancingPolicy getLoadBalancingPolicy() {
return policy;
}
@@ -71,18 +83,20 @@ public boolean equals(Object o) {
}
LbPolicyConfiguration that = (LbPolicyConfiguration) o;
return Objects.equals(routeLookupConfig, that.routeLookupConfig)
+ && Objects.equals(routeLookupChannelServiceConfig, that.routeLookupChannelServiceConfig)
&& Objects.equals(policy, that.policy);
}
@Override
public int hashCode() {
- return Objects.hash(routeLookupConfig, policy);
+ return Objects.hash(routeLookupConfig, routeLookupChannelServiceConfig, policy);
}
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
.add("routeLookupConfig", routeLookupConfig)
+ .add("routeLookupChannelServiceConfig", routeLookupChannelServiceConfig)
.add("policy", policy)
.toString();
}
@@ -191,33 +205,49 @@ public String toString() {
/** Factory for {@link ChildPolicyWrapper}. */
static final class RefCountedChildPolicyWrapperFactory {
+ // GuardedBy CachingRlsLbClient.lock
@VisibleForTesting
final Map childPolicyMap =
new HashMap<>();
private final ChildLoadBalancerHelperProvider childLbHelperProvider;
private final ChildLbStatusListener childLbStatusListener;
+ private final ChildLoadBalancingPolicy childPolicy;
+ private final ResolvedAddressFactory childLbResolvedAddressFactory;
public RefCountedChildPolicyWrapperFactory(
+ ChildLoadBalancingPolicy childPolicy,
+ ResolvedAddressFactory childLbResolvedAddressFactory,
ChildLoadBalancerHelperProvider childLbHelperProvider,
ChildLbStatusListener childLbStatusListener) {
+ this.childPolicy = checkNotNull(childPolicy, "childPolicy");
+ this.childLbResolvedAddressFactory =
+ checkNotNull(childLbResolvedAddressFactory, "childLbResolvedAddressFactory");
this.childLbHelperProvider = checkNotNull(childLbHelperProvider, "childLbHelperProvider");
this.childLbStatusListener = checkNotNull(childLbStatusListener, "childLbStatusListener");
}
+ // GuardedBy CachingRlsLbClient.lock
ChildPolicyWrapper createOrGet(String target) {
// TODO(creamsoup) check if the target is valid or not
RefCountedChildPolicyWrapper pooledChildPolicyWrapper = childPolicyMap.get(target);
if (pooledChildPolicyWrapper == null) {
- ChildPolicyWrapper childPolicyWrapper =
- new ChildPolicyWrapper(target, childLbHelperProvider, childLbStatusListener);
+ ChildPolicyWrapper childPolicyWrapper = new ChildPolicyWrapper(
+ target, childPolicy, childLbResolvedAddressFactory, childLbHelperProvider,
+ childLbStatusListener);
pooledChildPolicyWrapper = RefCountedChildPolicyWrapper.of(childPolicyWrapper);
childPolicyMap.put(target, pooledChildPolicyWrapper);
+ return pooledChildPolicyWrapper.getObject();
+ } else {
+ ChildPolicyWrapper childPolicyWrapper = pooledChildPolicyWrapper.getObject();
+ if (childPolicyWrapper.getPicker() != null) {
+ childPolicyWrapper.refreshState();
+ }
+ return childPolicyWrapper;
}
-
- return pooledChildPolicyWrapper.getObject();
}
+ // GuardedBy CachingRlsLbClient.lock
void release(ChildPolicyWrapper childPolicyWrapper) {
checkNotNull(childPolicyWrapper, "childPolicyWrapper");
String target = childPolicyWrapper.getTarget();
@@ -238,16 +268,36 @@ static final class ChildPolicyWrapper {
private final String target;
private final ChildPolicyReportingHelper helper;
+ private final LoadBalancer lb;
private volatile SubchannelPicker picker;
private ConnectivityState state;
public ChildPolicyWrapper(
String target,
+ ChildLoadBalancingPolicy childPolicy,
+ final ResolvedAddressFactory childLbResolvedAddressFactory,
ChildLoadBalancerHelperProvider childLbHelperProvider,
ChildLbStatusListener childLbStatusListener) {
this.target = target;
this.helper =
new ChildPolicyReportingHelper(childLbHelperProvider, childLbStatusListener);
+ LoadBalancerProvider lbProvider = childPolicy.getEffectiveLbProvider();
+ final ConfigOrError lbConfig =
+ lbProvider
+ .parseLoadBalancingPolicyConfig(
+ childPolicy.getEffectiveChildPolicy(target));
+ this.lb = lbProvider.newLoadBalancer(helper);
+ helper.getChannelLogger().log(
+ ChannelLogLevel.DEBUG, "RLS child lb created. config: {0}", lbConfig.getConfig());
+ helper.getSynchronizationContext().execute(
+ new Runnable() {
+ @Override
+ public void run() {
+ lb.handleResolvedAddresses(
+ childLbResolvedAddressFactory.create(lbConfig.getConfig()));
+ lb.requestConnection();
+ }
+ });
}
String getTarget() {
@@ -263,7 +313,25 @@ ChildPolicyReportingHelper getHelper() {
}
void refreshState() {
- helper.updateBalancingState(state, picker);
+ helper.getSynchronizationContext().execute(
+ new Runnable() {
+ @Override
+ public void run() {
+ helper.updateBalancingState(state, picker);
+ }
+ }
+ );
+ }
+
+ void shutdown() {
+ helper.getSynchronizationContext().execute(
+ new Runnable() {
+ @Override
+ public void run() {
+ lb.shutdown();
+ }
+ }
+ );
}
@Override
@@ -346,6 +414,7 @@ public ChildPolicyWrapper returnObject(Object object) {
long newCnt = refCnt.decrementAndGet();
checkState(newCnt != -1, "Cannot return never pooled childPolicyWrapper");
if (newCnt == 0) {
+ childPolicyWrapper.shutdown();
childPolicyWrapper = null;
}
return null;
diff --git a/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java b/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
index 2d60f103a60..9c1a24a0d1e 100644
--- a/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
+++ b/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
@@ -48,7 +48,7 @@
@ThreadSafe
abstract class LinkedHashLruCache implements LruCache {
- private final Object lock = new Object();
+ private final Object lock;
@GuardedBy("lock")
private final LinkedHashMap delegate;
@@ -64,9 +64,11 @@ abstract class LinkedHashLruCache implements LruCache {
int cleaningInterval,
TimeUnit cleaningIntervalUnit,
ScheduledExecutorService ses,
- final TimeProvider timeProvider) {
+ final TimeProvider timeProvider,
+ Object lock) {
checkState(estimatedMaxSizeBytes > 0, "max estimated cache size should be positive");
this.estimatedMaxSizeBytes = estimatedMaxSizeBytes;
+ this.lock = checkNotNull(lock, "lock");
this.evictionListener = new SizeHandlingEvictionListener(evictionListener);
this.timeProvider = checkNotNull(timeProvider, "timeProvider");
delegate = new LinkedHashMap(
@@ -200,14 +202,15 @@ private V invalidate(K key, EvictionType cause) {
}
@Override
- public final void invalidateAll(Iterable keys) {
- checkNotNull(keys, "keys");
+ public final void invalidateAll() {
synchronized (lock) {
- for (K key : keys) {
- SizedValue existing = delegate.remove(key);
- if (existing != null) {
- evictionListener.onEviction(key, existing, EvictionType.EXPLICIT);
+ Iterator> iterator = delegate.entrySet().iterator();
+ while (iterator.hasNext()) {
+ Map.Entry entry = iterator.next();
+ if (entry.getValue() != null) {
+ evictionListener.onEviction(entry.getKey(), entry.getValue(), EvictionType.EXPLICIT);
}
+ iterator.remove();
}
}
}
@@ -291,13 +294,10 @@ private boolean cleanupExpiredEntries(int maxExpiredEntries, long now) {
public final void close() {
synchronized (lock) {
periodicCleaner.stop();
- doClose();
- delegate.clear();
+ invalidateAll();
}
}
- protected void doClose() {}
-
/** Periodically cleans up the AsyncRequestCache. */
private final class PeriodicCleaner {
diff --git a/rls/src/main/java/io/grpc/rls/LruCache.java b/rls/src/main/java/io/grpc/rls/LruCache.java
index 6ab5c4bcb46..1ad5a958289 100644
--- a/rls/src/main/java/io/grpc/rls/LruCache.java
+++ b/rls/src/main/java/io/grpc/rls/LruCache.java
@@ -49,10 +49,10 @@ interface LruCache {
V invalidate(K key);
/**
- * Invalidates cache entries for given keys. This operation will trigger {@link EvictionListener}
+ * Invalidates cache entries for all keys. This operation will trigger {@link EvictionListener}
* with {@link EvictionType#EXPLICIT}.
*/
- void invalidateAll(Iterable keys);
+ void invalidateAll();
/** Returns {@code true} if given key is cached. */
@CheckReturnValue
diff --git a/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java b/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
index 289098e2554..2aac96cadcf 100644
--- a/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
+++ b/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
@@ -56,8 +56,8 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
checkNotNull(lbPolicyConfiguration, "Missing rls lb config");
if (!lbPolicyConfiguration.equals(this.lbPolicyConfiguration)) {
boolean needToConnect = this.lbPolicyConfiguration == null
- || !this.lbPolicyConfiguration.getRouteLookupConfig().getLookupService().equals(
- lbPolicyConfiguration.getRouteLookupConfig().getLookupService());
+ || !this.lbPolicyConfiguration.getRouteLookupConfig().lookupService().equals(
+ lbPolicyConfiguration.getRouteLookupConfig().lookupService());
if (needToConnect) {
if (routeLookupClient != null) {
routeLookupClient.close();
diff --git a/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java b/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
index 3755fe3f77c..54ef848498c 100644
--- a/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
+++ b/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
@@ -30,9 +30,9 @@
import java.util.Map;
/**
- * The provider for the "rls-experimental" balancing policy. This class should not be directly
+ * The provider for the "rls_experimental" balancing policy. This class should not be directly
* referenced in code. The policy should be accessed through {@link
- * io.grpc.LoadBalancerRegistry#getProvider} with the name "rls-experimental".
+ * io.grpc.LoadBalancerRegistry#getProvider} with the name "rls_experimental".
*/
@Internal
public final class RlsLoadBalancerProvider extends LoadBalancerProvider {
@@ -49,7 +49,7 @@ public int getPriority() {
@Override
public String getPolicyName() {
- return "rls-experimental";
+ return "rls_experimental";
}
@Override
@@ -62,12 +62,15 @@ public ConfigOrError parseLoadBalancingPolicyConfig(Map rawLoadBalanc
try {
RouteLookupConfig routeLookupConfig = new RouteLookupConfigConverter()
.convert(JsonUtil.getObject(rawLoadBalancingConfigPolicy, "routeLookupConfig"));
+ Map routeLookupChannelServiceConfig =
+ JsonUtil.getObject(rawLoadBalancingConfigPolicy, "routeLookupChannelServiceConfig");
ChildLoadBalancingPolicy lbPolicy = ChildLoadBalancingPolicy
.create(
JsonUtil.getString(rawLoadBalancingConfigPolicy, "childPolicyConfigTargetFieldName"),
JsonUtil.checkObjectList(
checkNotNull(JsonUtil.getList(rawLoadBalancingConfigPolicy, "childPolicy"))));
- return ConfigOrError.fromConfig(new LbPolicyConfiguration(routeLookupConfig, lbPolicy));
+ return ConfigOrError.fromConfig(
+ new LbPolicyConfiguration(routeLookupConfig, routeLookupChannelServiceConfig, lbPolicy));
} catch (Exception e) {
return ConfigOrError.fromError(
Status.INVALID_ARGUMENT
diff --git a/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java b/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java
index b4d3fcc3b29..14e3e50bd49 100644
--- a/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java
+++ b/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java
@@ -63,7 +63,8 @@ static final class RouteLookupRequestConverter
@Override
protected RlsProtoData.RouteLookupRequest doForward(RouteLookupRequest routeLookupRequest) {
- return new RlsProtoData.RouteLookupRequest(routeLookupRequest.getKeyMapMap());
+ return RlsProtoData.RouteLookupRequest.create(
+ ImmutableMap.copyOf(routeLookupRequest.getKeyMapMap()));
}
@Override
@@ -71,7 +72,7 @@ protected RouteLookupRequest doBackward(RlsProtoData.RouteLookupRequest routeLoo
return
RouteLookupRequest.newBuilder()
.setTargetType("grpc")
- .putAllKeyMap(routeLookupRequest.getKeyMap())
+ .putAllKeyMap(routeLookupRequest.keyMap())
.build();
}
}
@@ -86,15 +87,15 @@ static final class RouteLookupResponseConverter
@Override
protected RlsProtoData.RouteLookupResponse doForward(RouteLookupResponse routeLookupResponse) {
return
- new RlsProtoData.RouteLookupResponse(
- routeLookupResponse.getTargetsList(),
+ RlsProtoData.RouteLookupResponse.create(
+ ImmutableList.copyOf(routeLookupResponse.getTargetsList()),
routeLookupResponse.getHeaderData());
}
@Override
protected RouteLookupResponse doBackward(RlsProtoData.RouteLookupResponse routeLookupResponse) {
return RouteLookupResponse.newBuilder()
- .addAllTargets(routeLookupResponse.getTargets())
+ .addAllTargets(routeLookupResponse.targets())
.setHeaderData(routeLookupResponse.getHeaderData())
.build();
}
@@ -108,13 +109,13 @@ static final class RouteLookupConfigConverter
@Override
protected RouteLookupConfig doForward(Map json) {
- List grpcKeyBuilders =
+ ImmutableList grpcKeyBuilders =
GrpcKeyBuilderConverter.covertAll(
checkNotNull(JsonUtil.getListOfObjects(json, "grpcKeyBuilders"), "grpcKeyBuilders"));
checkArgument(!grpcKeyBuilders.isEmpty(), "must have at least one GrpcKeyBuilder");
Set names = new HashSet<>();
for (GrpcKeyBuilder keyBuilder : grpcKeyBuilders) {
- for (Name name : keyBuilder.getNames()) {
+ for (Name name : keyBuilder.names()) {
checkArgument(names.add(name), "duplicate names in grpc_keybuilders: " + name);
}
}
@@ -145,14 +146,15 @@ protected RouteLookupConfig doForward(Map json) {
checkArgument(cacheSize > 0, "cacheSize must be positive");
cacheSize = Math.min(cacheSize, MAX_CACHE_SIZE);
String defaultTarget = Strings.emptyToNull(JsonUtil.getString(json, "defaultTarget"));
- return new RouteLookupConfig(
- grpcKeyBuilders,
- lookupService,
- /* lookupServiceTimeoutInNanos= */ timeout,
- /* maxAgeInNanos= */ maxAge,
- /* staleAgeInNanos= */ staleAge,
- /* cacheSizeBytes= */ cacheSize,
- defaultTarget);
+ return RouteLookupConfig.builder()
+ .grpcKeyBuilders(grpcKeyBuilders)
+ .lookupService(lookupService)
+ .lookupServiceTimeoutInNanos(timeout)
+ .maxAgeInNanos(maxAge)
+ .staleAgeInNanos(staleAge)
+ .cacheSizeBytes(cacheSize)
+ .defaultTarget(defaultTarget)
+ .build();
}
private static T orDefault(@Nullable T value, T defaultValue) {
@@ -169,12 +171,12 @@ protected Map doBackward(RouteLookupConfig routeLookupConfig) {
}
private static final class GrpcKeyBuilderConverter {
- public static List covertAll(List> keyBuilders) {
- List keyBuilderList = new ArrayList<>();
+ public static ImmutableList covertAll(List> keyBuilders) {
+ ImmutableList.Builder keyBuilderList = ImmutableList.builder();
for (Map keyBuilder : keyBuilders) {
keyBuilderList.add(convert(keyBuilder));
}
- return keyBuilderList;
+ return keyBuilderList.build();
}
@SuppressWarnings("unchecked")
@@ -184,25 +186,26 @@ static GrpcKeyBuilder convert(Map keyBuilder) {
rawRawNames != null && !rawRawNames.isEmpty(),
"each keyBuilder must have at least one name");
List> rawNames = JsonUtil.checkObjectList(rawRawNames);
- List names = new ArrayList<>();
+ ImmutableList.Builder namesBuilder = ImmutableList.builder();
for (Map rawName : rawNames) {
String serviceName = JsonUtil.getString(rawName, "service");
checkArgument(!Strings.isNullOrEmpty(serviceName), "service must not be empty or null");
- names.add(new Name(serviceName, JsonUtil.getString(rawName, "method")));
+ namesBuilder.add(Name.create(serviceName, JsonUtil.getString(rawName, "method")));
}
List rawRawHeaders = JsonUtil.getList(keyBuilder, "headers");
List> rawHeaders =
rawRawHeaders == null
? new ArrayList>() : JsonUtil.checkObjectList(rawRawHeaders);
- List nameMatchers = new ArrayList<>();
+ ImmutableList.Builder nameMatchersBuilder = ImmutableList.builder();
for (Map rawHeader : rawHeaders) {
Boolean requiredMatch = JsonUtil.getBoolean(rawHeader, "requiredMatch");
checkArgument(
requiredMatch == null || !requiredMatch,
"requiredMatch shouldn't be specified for gRPC");
- NameMatcher matcher = new NameMatcher(
- JsonUtil.getString(rawHeader, "key"), (List) rawHeader.get("names"));
- nameMatchers.add(matcher);
+ NameMatcher matcher = NameMatcher.create(
+ JsonUtil.getString(rawHeader, "key"),
+ ImmutableList.copyOf((List) rawHeader.get("names")));
+ nameMatchersBuilder.add(matcher);
}
ExtraKeys extraKeys = ExtraKeys.DEFAULT;
Map rawExtraKeys =
@@ -216,8 +219,10 @@ static GrpcKeyBuilder convert(Map keyBuilder) {
if (constantKeys == null) {
constantKeys = ImmutableMap.of();
}
+ ImmutableList nameMatchers = nameMatchersBuilder.build();
checkUniqueKey(nameMatchers, constantKeys.keySet());
- return new GrpcKeyBuilder(names, nameMatchers, extraKeys, constantKeys);
+ return GrpcKeyBuilder.create(
+ namesBuilder.build(), nameMatchers, extraKeys, ImmutableMap.copyOf(constantKeys));
}
}
@@ -225,7 +230,7 @@ private static void checkUniqueKey(List nameMatchers, Set c
Set keys = new HashSet<>(constantKeys);
keys.addAll(EXTRA_KEY_NAMES);
for (NameMatcher nameMatcher : nameMatchers) {
- keys.add(nameMatcher.getKey());
+ keys.add(nameMatcher.key());
}
if (keys.size() != nameMatchers.size() + constantKeys.size() + EXTRA_KEY_NAMES.size()) {
throw new IllegalArgumentException("keys in KeyBuilder must be unique");
diff --git a/rls/src/main/java/io/grpc/rls/RlsProtoData.java b/rls/src/main/java/io/grpc/rls/RlsProtoData.java
index 4709894833c..929b7800759 100644
--- a/rls/src/main/java/io/grpc/rls/RlsProtoData.java
+++ b/rls/src/main/java/io/grpc/rls/RlsProtoData.java
@@ -16,16 +16,9 @@
package io.grpc.rls;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
import com.google.auto.value.AutoValue;
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import java.util.List;
-import java.util.Map;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
@@ -35,140 +28,46 @@ final class RlsProtoData {
private RlsProtoData() {}
/** A request object sent to route lookup service. */
+ @AutoValue
@Immutable
- static final class RouteLookupRequest {
-
- private final ImmutableMap keyMap;
-
- RouteLookupRequest(Map keyMap) {
- this.keyMap = ImmutableMap.copyOf(checkNotNull(keyMap, "keyMap"));
- }
+ abstract static class RouteLookupRequest {
/** Returns a map of key values extracted via key builders for the gRPC or HTTP request. */
- ImmutableMap getKeyMap() {
- return keyMap;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- RouteLookupRequest that = (RouteLookupRequest) o;
- return Objects.equal(keyMap, that.keyMap);
- }
-
- @Override
- public int hashCode() {
- return Objects.hashCode(keyMap);
- }
+ abstract ImmutableMap keyMap();
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("keyMap", keyMap)
- .toString();
+ static RouteLookupRequest create(ImmutableMap keyMap) {
+ return new AutoValue_RlsProtoData_RouteLookupRequest(keyMap);
}
}
/** A response from route lookup service. */
+ @AutoValue
@Immutable
- static final class RouteLookupResponse {
-
- private final ImmutableList targets;
-
- private final String headerData;
-
- RouteLookupResponse(List targets, String headerData) {
- checkState(targets != null && !targets.isEmpty(), "targets cannot be empty or null");
- this.targets = ImmutableList.copyOf(targets);
- this.headerData = checkNotNull(headerData, "headerData");
- }
+ abstract static class RouteLookupResponse {
/**
* Returns list of targets. Prioritized list (best one first) of addressable entities to use for
* routing, using syntax requested by the request target_type. The targets will be tried in
* order until a healthy one is found.
*/
- ImmutableList getTargets() {
- return targets;
- }
+ abstract ImmutableList targets();
/**
* Returns optional header data to pass along to AFE in the X-Google-RLS-Data header. Cached
* with "target" and sent with all requests that match the request key. Allows the RLS to pass
* its work product to the eventual target.
*/
- String getHeaderData() {
- return headerData;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- RouteLookupResponse that = (RouteLookupResponse) o;
- return java.util.Objects.equals(targets, that.targets)
- && java.util.Objects.equals(headerData, that.headerData);
- }
+ abstract String getHeaderData();
- @Override
- public int hashCode() {
- return java.util.Objects.hash(targets, headerData);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("targets", targets)
- .add("headerData", headerData)
- .toString();
+ static RouteLookupResponse create(ImmutableList targets, String getHeaderData) {
+ return new AutoValue_RlsProtoData_RouteLookupResponse(targets, getHeaderData);
}
}
/** A config object for gRPC RouteLookupService. */
+ @AutoValue
@Immutable
- static final class RouteLookupConfig {
-
- private final ImmutableList grpcKeyBuilders;
-
- private final String lookupService;
-
- private final long lookupServiceTimeoutInNanos;
-
- private final long maxAgeInNanos;
-
- private final long staleAgeInNanos;
-
- private final long cacheSizeBytes;
-
- @Nullable
- private final String defaultTarget;
-
- RouteLookupConfig(
- List grpcKeyBuilders,
- String lookupService,
- long lookupServiceTimeoutInNanos,
- long maxAgeInNanos,
- long staleAgeInNanos,
- long cacheSizeBytes,
- @Nullable
- String defaultTarget) {
- this.grpcKeyBuilders = ImmutableList.copyOf(grpcKeyBuilders);
- this.lookupService = lookupService;
- this.lookupServiceTimeoutInNanos = lookupServiceTimeoutInNanos;
- this.maxAgeInNanos = maxAgeInNanos;
- this.staleAgeInNanos = staleAgeInNanos;
- this.cacheSizeBytes = cacheSizeBytes;
- this.defaultTarget = defaultTarget;
- }
+ abstract static class RouteLookupConfig {
/**
* Returns unordered specifications for constructing keys for gRPC requests. All GrpcKeyBuilders
@@ -176,36 +75,25 @@ static final class RouteLookupConfig {
* keyed by name. If no GrpcKeyBuilder matches, an empty key_map will be sent to the lookup
* service; it should likely reply with a global default route and raise an alert.
*/
- ImmutableList getGrpcKeyBuilders() {
- return grpcKeyBuilders;
- }
+ abstract ImmutableList grpcKeyBuilders();
/**
* Returns the name of the lookup service as a gRPC URI. Typically, this will be a subdomain of
* the target, such as "lookup.datastore.googleapis.com".
*/
- String getLookupService() {
- return lookupService;
- }
+ abstract String lookupService();
/** Returns the timeout value for lookup service requests. */
- long getLookupServiceTimeoutInNanos() {
- return lookupServiceTimeoutInNanos;
- }
-
+ abstract long lookupServiceTimeoutInNanos();
/** Returns the maximum age the result will be cached. */
- long getMaxAgeInNanos() {
- return maxAgeInNanos;
- }
+ abstract long maxAgeInNanos();
/**
* Returns the time when an entry will be in a staled status. When cache is accessed whgen the
* entry is in staled status, it will
*/
- long getStaleAgeInNanos() {
- return staleAgeInNanos;
- }
+ abstract long staleAgeInNanos();
/**
* Returns a rough indicator of amount of memory to use for the client cache. Some of the data
@@ -213,9 +101,7 @@ long getStaleAgeInNanos() {
* than this value. If this field is omitted or set to zero, a client default will be used.
* The value may be capped to a lower amount based on client configuration.
*/
- long getCacheSizeBytes() {
- return cacheSizeBytes;
- }
+ abstract long cacheSizeBytes();
/**
* Returns the default target to use if needed. If nonempty (implies request processing
@@ -224,51 +110,30 @@ long getCacheSizeBytes() {
* {@literal e.g.} "us_east_1.cloudbigtable.googleapis.com".
*/
@Nullable
- String getDefaultTarget() {
- return defaultTarget;
- }
+ abstract String defaultTarget();
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- RouteLookupConfig that = (RouteLookupConfig) o;
- return lookupServiceTimeoutInNanos == that.lookupServiceTimeoutInNanos
- && maxAgeInNanos == that.maxAgeInNanos
- && staleAgeInNanos == that.staleAgeInNanos
- && cacheSizeBytes == that.cacheSizeBytes
- && Objects.equal(grpcKeyBuilders, that.grpcKeyBuilders)
- && Objects.equal(lookupService, that.lookupService)
- && Objects.equal(defaultTarget, that.defaultTarget);
+ static Builder builder() {
+ return new AutoValue_RlsProtoData_RouteLookupConfig.Builder();
}
- @Override
- public int hashCode() {
- return Objects.hashCode(
- grpcKeyBuilders,
- lookupService,
- lookupServiceTimeoutInNanos,
- maxAgeInNanos,
- staleAgeInNanos,
- cacheSizeBytes,
- defaultTarget);
- }
+ @AutoValue.Builder
+ abstract static class Builder {
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("grpcKeyBuilders", grpcKeyBuilders)
- .add("lookupService", lookupService)
- .add("lookupServiceTimeoutInNanos", lookupServiceTimeoutInNanos)
- .add("maxAgeInNanos", maxAgeInNanos)
- .add("staleAgeInNanos", staleAgeInNanos)
- .add("cacheSize", cacheSizeBytes)
- .add("defaultTarget", defaultTarget)
- .toString();
+ abstract Builder grpcKeyBuilders(ImmutableList grpcKeyBuilders);
+
+ abstract Builder lookupService(String lookupService);
+
+ abstract Builder lookupServiceTimeoutInNanos(long lookupServiceTimeoutInNanos);
+
+ abstract Builder maxAgeInNanos(long maxAgeInNanos);
+
+ abstract Builder staleAgeInNanos(long staleAgeInNanos);
+
+ abstract Builder cacheSizeBytes(long cacheSizeBytes);
+
+ abstract Builder defaultTarget(@Nullable String defaultTarget);
+
+ abstract RouteLookupConfig build();
}
}
@@ -277,74 +142,25 @@ public String toString() {
* The name must match one of the names listed in the "name" field. If the "required_match" field
* is true, one of the specified names must be present for the keybuilder to match.
*/
+ @AutoValue
@Immutable
- static final class NameMatcher {
-
- private final String key;
-
- private final ImmutableList names;
-
- NameMatcher(String key, List names) {
- this.key = checkNotNull(key, "key");
- this.names = ImmutableList.copyOf(checkNotNull(names, "names"));
- }
+ abstract static class NameMatcher {
/** The name that will be used in the RLS key_map to refer to this value. */
- String getKey() {
- return key;
- }
+ abstract String key();
/** Returns ordered list of names; the first non-empty value will be used. */
- ImmutableList names() {
- return names;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- NameMatcher matcher = (NameMatcher) o;
- return java.util.Objects.equals(key, matcher.key)
- && java.util.Objects.equals(names, matcher.names);
- }
+ abstract ImmutableList names();
- @Override
- public int hashCode() {
- return java.util.Objects.hash(key, names);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("key", key)
- .add("names", names)
- .toString();
+ static NameMatcher create(String key, ImmutableList names) {
+ return new AutoValue_RlsProtoData_NameMatcher(key, names);
}
}
/** GrpcKeyBuilder is a configuration to construct headers consumed by route lookup service. */
- static final class GrpcKeyBuilder {
-
- private final ImmutableList names;
-
- private final ImmutableList headers;
- private final ExtraKeys extraKeys;
- private final ImmutableMap constantKeys;
-
- /** Constructor. All args should be nonnull. Headers should head unique keys. */
- GrpcKeyBuilder(
- List names, List headers, ExtraKeys extraKeys,
- Map constantKeys) {
- checkState(names != null && !names.isEmpty(), "names cannot be empty");
- this.names = ImmutableList.copyOf(names);
- this.headers = ImmutableList.copyOf(headers);
- this.extraKeys = checkNotNull(extraKeys, "extraKeys");
- this.constantKeys = ImmutableMap.copyOf(checkNotNull(constantKeys, "constantKeys"));
- }
+ @AutoValue
+ @Immutable
+ abstract static class GrpcKeyBuilder {
/**
* Returns names. To match, one of the given Name fields must match; the service and method
@@ -352,53 +168,23 @@ static final class GrpcKeyBuilder {
* package name. The method name may be omitted, in which case any method on the given service
* is matched.
*/
- ImmutableList getNames() {
- return names;
- }
+ abstract ImmutableList names();
/**
* Returns a list of NameMatchers for header. Extract keys from all listed headers. For gRPC, it
* is an error to specify "required_match" on the NameMatcher protos, and we ignore it if set.
*/
- ImmutableList getHeaders() {
- return headers;
- }
+ abstract ImmutableList headers();
- ExtraKeys getExtraKeys() {
- return extraKeys;
- }
+ abstract ExtraKeys extraKeys();
- ImmutableMap getConstantKeys() {
- return constantKeys;
- }
+ abstract ImmutableMap constantKeys();
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- GrpcKeyBuilder that = (GrpcKeyBuilder) o;
- return Objects.equal(names, that.names) && Objects.equal(headers, that.headers)
- && Objects.equal(extraKeys, that.extraKeys)
- && Objects.equal(constantKeys, that.constantKeys);
- }
-
- @Override
- public int hashCode() {
- return Objects.hashCode(names, headers, extraKeys, constantKeys);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("names", names)
- .add("headers", headers)
- .add("extraKeys", extraKeys)
- .add("constantKeys", constantKeys)
- .toString();
+ static GrpcKeyBuilder create(
+ ImmutableList names,
+ ImmutableList headers,
+ ExtraKeys extraKeys, ImmutableMap constantKeys) {
+ return new AutoValue_RlsProtoData_GrpcKeyBuilder(names, headers, extraKeys, constantKeys);
}
/**
@@ -407,57 +193,23 @@ public String toString() {
* required and includes the proto package name. The method name may be omitted, in which case
* any method on the given service is matched.
*/
- static final class Name {
-
- private final String service;
+ @AutoValue
+ @Immutable
+ abstract static class Name {
- @Nullable
- private final String method;
-
- /** The primary constructor. */
- Name(String service, @Nullable String method) {
- this.service = service;
- this.method = method;
- }
-
- String getService() {
- return service;
- }
+ abstract String service();
@Nullable
- String getMethod() {
- return method;
- }
+ abstract String method();
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- Name name = (Name) o;
- return Objects.equal(service, name.service)
- && Objects.equal(method, name.method);
- }
-
- @Override
- public int hashCode() {
- return Objects.hashCode(service, method);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("service", service)
- .add("method", method)
- .toString();
+ static Name create(String service, @Nullable String method) {
+ return new AutoValue_RlsProtoData_GrpcKeyBuilder_Name(service, method);
}
}
}
@AutoValue
+ @Immutable
abstract static class ExtraKeys {
static final ExtraKeys DEFAULT = create(null, null, null);
diff --git a/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java b/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java
index d3aecabd034..4a32bece2b2 100644
--- a/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java
+++ b/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java
@@ -50,11 +50,11 @@ final class RlsRequestFactory {
private static Map createKeyBuilderTable(
RouteLookupConfig config) {
Map table = new HashMap<>();
- for (GrpcKeyBuilder grpcKeyBuilder : config.getGrpcKeyBuilders()) {
- for (Name name : grpcKeyBuilder.getNames()) {
- boolean hasMethod = name.getMethod() == null || name.getMethod().isEmpty();
- String method = hasMethod ? "*" : name.getMethod();
- String path = "/" + name.getService() + "/" + method;
+ for (GrpcKeyBuilder grpcKeyBuilder : config.grpcKeyBuilders()) {
+ for (Name name : grpcKeyBuilder.names()) {
+ boolean hasMethod = name.method() == null || name.method().isEmpty();
+ String method = hasMethod ? "*" : name.method();
+ String path = "/" + name.service() + "/" + method;
table.put(path, grpcKeyBuilder);
}
}
@@ -73,12 +73,12 @@ RouteLookupRequest create(String service, String method, Metadata metadata) {
grpcKeyBuilder = keyBuilderTable.get("/" + service + "/*");
}
if (grpcKeyBuilder == null) {
- return new RouteLookupRequest(ImmutableMap.of());
+ return RouteLookupRequest.create(ImmutableMap.of());
}
- Map rlsRequestHeaders =
- createRequestHeaders(metadata, grpcKeyBuilder.getHeaders());
- ExtraKeys extraKeys = grpcKeyBuilder.getExtraKeys();
- Map constantKeys = grpcKeyBuilder.getConstantKeys();
+ ImmutableMap.Builder rlsRequestHeaders =
+ createRequestHeaders(metadata, grpcKeyBuilder.headers());
+ ExtraKeys extraKeys = grpcKeyBuilder.extraKeys();
+ Map constantKeys = grpcKeyBuilder.constantKeys();
if (extraKeys.host() != null) {
rlsRequestHeaders.put(extraKeys.host(), target);
}
@@ -89,12 +89,12 @@ RouteLookupRequest create(String service, String method, Metadata metadata) {
rlsRequestHeaders.put(extraKeys.method(), method);
}
rlsRequestHeaders.putAll(constantKeys);
- return new RouteLookupRequest(rlsRequestHeaders);
+ return RouteLookupRequest.create(rlsRequestHeaders.build());
}
- private Map createRequestHeaders(
+ private ImmutableMap.Builder