From d537adedb3f80ae7f0dc5c4a4e5b6567e7d71415 Mon Sep 17 00:00:00 2001 From: Chengyuan Zhang Date: Thu, 19 Mar 2020 12:37:48 -0700 Subject: [PATCH] android-interop-testing: include android interop testing in main build (#6829) Proto generated code for android-interop-testing is checked in. --- RELEASING.md | 3 - android-interop-testing/README.md | 2 - android-interop-testing/app/build.gradle | 88 -- android-interop-testing/build.gradle | 123 ++- .../{app => }/proguard-rules.pro | 0 android-interop-testing/settings.gradle | 1 - .../src/androidTest/AndroidManifest.xml | 0 .../InteropInstrumentationTest.java | 0 .../LoadBalancerStatsServiceGrpc.java | 278 ++++++ .../integration/MetricsServiceGrpc.java | 341 +++++++ .../integration/ReconnectServiceGrpc.java | 339 +++++++ .../testing/integration/TestServiceGrpc.java | 829 ++++++++++++++++++ .../integration/UnimplementedServiceGrpc.java | 283 ++++++ .../LoadBalancerStatsServiceGrpc.java | 278 ++++++ .../integration/MetricsServiceGrpc.java | 341 +++++++ .../integration/ReconnectServiceGrpc.java | 339 +++++++ .../testing/integration/TestServiceGrpc.java | 829 ++++++++++++++++++ .../integration/UnimplementedServiceGrpc.java | 283 ++++++ .../{app => }/src/main/AndroidManifest.xml | 4 +- .../android/integrationtest/InteropTask.java | 1 - .../integrationtest/TesterActivity.java | 4 +- .../TesterOkHttpChannelBuilder.java | 0 .../src/main/res/layout/activity_tester.xml | 0 .../src/main/res/mipmap-hdpi/ic_launcher.png | Bin .../src/main/res/mipmap-mdpi/ic_launcher.png | Bin .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin .../{app => }/src/main/res/raw/ca.pem | 0 .../{app => }/src/main/res/values/strings.xml | 0 build.gradle | 46 +- settings.gradle | 3 + 31 files changed, 4258 insertions(+), 157 deletions(-) delete mode 100644 android-interop-testing/app/build.gradle rename android-interop-testing/{app => }/proguard-rules.pro (100%) delete mode 100644 android-interop-testing/settings.gradle rename android-interop-testing/{app => }/src/androidTest/AndroidManifest.xml (100%) rename android-interop-testing/{app => }/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java (100%) create mode 100644 android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java create mode 100644 android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java create mode 100644 android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java create mode 100644 android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/TestServiceGrpc.java create mode 100644 android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java create mode 100644 android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java create mode 100644 android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java create mode 100644 android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java create mode 100644 android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/TestServiceGrpc.java create mode 100644 android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java rename android-interop-testing/{app => }/src/main/AndroidManifest.xml (91%) rename android-interop-testing/{app => }/src/main/java/io/grpc/android/integrationtest/InteropTask.java (99%) rename android-interop-testing/{app => }/src/main/java/io/grpc/android/integrationtest/TesterActivity.java (98%) rename android-interop-testing/{app => }/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java (100%) rename android-interop-testing/{app => }/src/main/res/layout/activity_tester.xml (100%) rename android-interop-testing/{app => }/src/main/res/mipmap-hdpi/ic_launcher.png (100%) rename android-interop-testing/{app => }/src/main/res/mipmap-mdpi/ic_launcher.png (100%) rename android-interop-testing/{app => }/src/main/res/mipmap-xhdpi/ic_launcher.png (100%) rename android-interop-testing/{app => }/src/main/res/mipmap-xxhdpi/ic_launcher.png (100%) rename android-interop-testing/{app => }/src/main/res/raw/ca.pem (100%) rename android-interop-testing/{app => }/src/main/res/values/strings.xml (100%) diff --git a/RELEASING.md b/RELEASING.md index b3d262a119..9d45bd9f5f 100644 --- a/RELEASING.md +++ b/RELEASING.md @@ -32,10 +32,7 @@ them before continuing, and set them again when resuming. $ MAJOR=1 MINOR=7 PATCH=0 # Set appropriately for new release $ VERSION_FILES=( build.gradle - android/build.gradle - android-interop-testing/app/build.gradle core/src/main/java/io/grpc/internal/GrpcUtil.java - cronet/build.gradle examples/build.gradle examples/pom.xml examples/android/clientcache/app/build.gradle diff --git a/android-interop-testing/README.md b/android-interop-testing/README.md index c1abcee4d7..bd7841e7e8 100644 --- a/android-interop-testing/README.md +++ b/android-interop-testing/README.md @@ -3,8 +3,6 @@ gRPC Android test App Implements gRPC integration tests in an Android App. -TODO(madongfly) integrate this App into the gRPC-Java build system. - In order to build this app, you need a local.properties file under this directory which specifies the location of your android sdk: ``` diff --git a/android-interop-testing/app/build.gradle b/android-interop-testing/app/build.gradle deleted file mode 100644 index 8c61372dc1..0000000000 --- a/android-interop-testing/app/build.gradle +++ /dev/null @@ -1,88 +0,0 @@ -apply plugin: 'com.android.application' -apply plugin: 'com.google.protobuf' - -android { - sourceSets { - main { - java { - srcDirs += "${projectDir}/../../interop-testing/src/main/java/" - setIncludes(["io/grpc/android/integrationtest/**", - "io/grpc/testing/integration/AbstractInteropTest.java", - "io/grpc/testing/integration/TestServiceImpl.java", - "io/grpc/testing/integration/Util.java"]) - } - proto { - srcDirs += "${projectDir}/../../interop-testing/src/main/proto/" - } - } - } - compileSdkVersion 26 - - defaultConfig { - applicationId "io.grpc.android.integrationtest" - // API level 14+ is required for TLS since Google Play Services v10.2 - minSdkVersion 14 - targetSdkVersion 26 - versionCode 1 - versionName "1.0" - testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" - multiDexEnabled true - } - buildTypes { - debug { minifyEnabled false } - release { - minifyEnabled true - proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' - } - } - lintOptions { disable 'InvalidPackage', 'HardcodedText' } -} - -protobuf { - protoc { artifact = 'com.google.protobuf:protoc:3.11.0' } - plugins { - grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.29.0-SNAPSHOT' // CURRENT_GRPC_VERSION - } - } - generateProtoTasks { - all().each { task -> - task.builtins { - java { option 'lite' } - } - task.plugins { - grpc { - // Options added to --grpc_out - option 'lite' - } - } - } - } -} - -dependencies { - implementation 'com.android.support:appcompat-v7:26.1.0' - implementation 'com.android.support:multidex:1.0.3' - implementation 'com.android.support:support-annotations:27.1.1' - implementation 'com.google.android.gms:play-services-base:15.0.1' - implementation ('com.google.auth:google-auth-library-oauth2-http:0.9.0') { - exclude group: 'org.apache.httpcomponents', module: 'httpclient' - } - implementation 'com.google.truth:truth:1.0.1' - implementation 'javax.annotation:javax.annotation-api:1.2' - implementation 'junit:junit:4.12' - - // You need to build grpc-java to obtain the grpc libraries below. - implementation 'io.grpc:grpc-auth:1.29.0-SNAPSHOT' // CURRENT_GRPC_VERSION - implementation 'io.grpc:grpc-census:1.29.0-SNAPSHOT' // CURRENT_GRPC_VERSION - implementation 'io.grpc:grpc-okhttp:1.29.0-SNAPSHOT' // CURRENT_GRPC_VERSION - implementation 'io.grpc:grpc-protobuf-lite:1.29.0-SNAPSHOT' // CURRENT_GRPC_VERSION - implementation 'io.grpc:grpc-stub:1.29.0-SNAPSHOT' // CURRENT_GRPC_VERSION - implementation 'io.grpc:grpc-testing:1.29.0-SNAPSHOT' // CURRENT_GRPC_VERSION - - androidTestImplementation 'androidx.test:rules:1.1.0-alpha1' - androidTestImplementation 'androidx.test:runner:1.1.0-alpha1' -} - -gradle.projectsEvaluated { - tasks.withType(JavaCompile) { options.compilerArgs << "-Xlint:deprecation" } -} diff --git a/android-interop-testing/build.gradle b/android-interop-testing/build.gradle index 2f363241d6..0c619f6b58 100644 --- a/android-interop-testing/build.gradle +++ b/android-interop-testing/build.gradle @@ -1,53 +1,90 @@ -// Top-level build file where you can add configuration options common to all sub-projects/modules. - -buildscript { - repositories { - google() - jcenter() - } - dependencies { - classpath 'com.android.tools.build:gradle:3.3.0' - classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.8" - - // NOTE: Do not place your application dependencies here; they belong - // in the individual module build.gradle files - } +plugins { + id "com.android.application" + id "com.google.protobuf" } -allprojects { - repositories { - google() - mavenLocal() - jcenter() - } +description = 'gRPC: Android Integration Testing' + +repositories { + google() + jcenter() } -subprojects { - apply plugin: "checkstyle" - - checkstyle { - configDir = file("$rootDir/../buildscripts") - toolVersion = "6.17" - ignoreFailures = false - if (rootProject.hasProperty("checkstyle.ignoreFailures")) { - ignoreFailures = rootProject.properties["checkstyle.ignoreFailures"].toBoolean() +android { + sourceSets { + main { + java { + srcDirs += "${projectDir}/../interop-testing/src/main/java/" + setIncludes(["io/grpc/android/integrationtest/**", + "io/grpc/testing/integration/AbstractInteropTest.java", + "io/grpc/testing/integration/TestServiceImpl.java", + "io/grpc/testing/integration/Util.java"]) + } + proto { + srcDirs += "${projectDir}/../interop-testing/src/main/proto/" + } } } + compileSdkVersion 26 - // Checkstyle doesn't run automatically with android - task checkStyleMain(type: Checkstyle) { - source 'src/main/java' - include '**/*.java' - classpath = files() + defaultConfig { + applicationId "io.grpc.android.integrationtest" + // API level 14+ is required for TLS since Google Play Services v10.2 + minSdkVersion 14 + targetSdkVersion 26 + versionCode 1 + versionName "1.0" + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + multiDexEnabled true } - - task checkStyleTest(type: Checkstyle) { - source 'src/test/java' - include '**/*.java' - classpath = files() - } - - afterEvaluate { project -> - project.tasks['check'].dependsOn checkStyleMain, checkStyleTest + buildTypes { + debug { minifyEnabled false } + release { + minifyEnabled true + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } } + lintOptions { disable 'InvalidPackage', 'HardcodedText' } } + +dependencies { + implementation 'com.android.support:appcompat-v7:26.1.0' + implementation 'com.android.support:multidex:1.0.3' + implementation 'com.android.support:support-annotations:27.1.1' + implementation 'com.google.android.gms:play-services-base:15.0.1' + + implementation project(':grpc-auth'), + project(':grpc-census'), + project(':grpc-okhttp'), + project(':grpc-protobuf-lite'), + project(':grpc-stub'), + project(':grpc-testing'), + libraries.junit, + libraries.truth + + implementation (libraries.google_auth_oauth2_http) { + exclude group: 'org.apache.httpcomponents' + } + + compileOnly libraries.javax_annotation + + androidTestImplementation 'androidx.test:rules:1.1.0-alpha1' + androidTestImplementation 'androidx.test:runner:1.1.0-alpha1' +} + +// Checkstyle doesn't run automatically with android +task checkStyleMain(type: Checkstyle) { + source 'src/main/java' + include '**/*.java' + classpath = files() +} + +task checkStyleTest(type: Checkstyle) { + source 'src/androidTest/java' + include '**/*.java' + classpath = files() +} + +project.tasks['check'].dependsOn checkStyleMain, checkStyleTest + +configureProtoCompilation() diff --git a/android-interop-testing/app/proguard-rules.pro b/android-interop-testing/proguard-rules.pro similarity index 100% rename from android-interop-testing/app/proguard-rules.pro rename to android-interop-testing/proguard-rules.pro diff --git a/android-interop-testing/settings.gradle b/android-interop-testing/settings.gradle deleted file mode 100644 index e7b4def49c..0000000000 --- a/android-interop-testing/settings.gradle +++ /dev/null @@ -1 +0,0 @@ -include ':app' diff --git a/android-interop-testing/app/src/androidTest/AndroidManifest.xml b/android-interop-testing/src/androidTest/AndroidManifest.xml similarity index 100% rename from android-interop-testing/app/src/androidTest/AndroidManifest.xml rename to android-interop-testing/src/androidTest/AndroidManifest.xml diff --git a/android-interop-testing/app/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java b/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java similarity index 100% rename from android-interop-testing/app/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java rename to android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java new file mode 100644 index 0000000000..26ac2a72df --- /dev/null +++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java @@ -0,0 +1,278 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A service used to obtain stats for verifying LB behavior.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class LoadBalancerStatsServiceGrpc { + + private LoadBalancerStatsServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getGetClientStatsMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetClientStats", + requestType = io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.class, + responseType = io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getGetClientStatsMethod() { + io.grpc.MethodDescriptor getGetClientStatsMethod; + if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) { + synchronized (LoadBalancerStatsServiceGrpc.class) { + if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) { + LoadBalancerStatsServiceGrpc.getGetClientStatsMethod = getGetClientStatsMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientStats")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.getDefaultInstance())) + .build(); + } + } + } + return getGetClientStatsMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceStub(channel, callOptions); + } + }; + return LoadBalancerStatsServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static LoadBalancerStatsServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public LoadBalancerStatsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceBlockingStub(channel, callOptions); + } + }; + return LoadBalancerStatsServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static LoadBalancerStatsServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceFutureStub(channel, callOptions); + } + }; + return LoadBalancerStatsServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static abstract class LoadBalancerStatsServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getGetClientStatsMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getGetClientStatsMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, + io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>( + this, METHODID_GET_CLIENT_STATS))) + .build(); + } + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static final class LoadBalancerStatsServiceStub extends io.grpc.stub.AbstractAsyncStub { + private LoadBalancerStatsServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected LoadBalancerStatsServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceStub(channel, callOptions); + } + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static final class LoadBalancerStatsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private LoadBalancerStatsServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected LoadBalancerStatsServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) { + return blockingUnaryCall( + getChannel(), getGetClientStatsMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static final class LoadBalancerStatsServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private LoadBalancerStatsServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected LoadBalancerStatsServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture getClientStats( + io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) { + return futureUnaryCall( + getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_GET_CLIENT_STATS = 0; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final LoadBalancerStatsServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(LoadBalancerStatsServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_GET_CLIENT_STATS: + serviceImpl.getClientStats((io.grpc.testing.integration.Messages.LoadBalancerStatsRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (LoadBalancerStatsServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getGetClientStatsMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java new file mode 100644 index 0000000000..470c3bcee0 --- /dev/null +++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java @@ -0,0 +1,341 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/metrics.proto") +public final class MetricsServiceGrpc { + + private MetricsServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.MetricsService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getGetAllGaugesMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetAllGauges", + requestType = io.grpc.testing.integration.Metrics.EmptyMessage.class, + responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + public static io.grpc.MethodDescriptor getGetAllGaugesMethod() { + io.grpc.MethodDescriptor getGetAllGaugesMethod; + if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) { + synchronized (MetricsServiceGrpc.class) { + if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) { + MetricsServiceGrpc.getGetAllGaugesMethod = getGetAllGaugesMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAllGauges")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance())) + .build(); + } + } + } + return getGetAllGaugesMethod; + } + + private static volatile io.grpc.MethodDescriptor getGetGaugeMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetGauge", + requestType = io.grpc.testing.integration.Metrics.GaugeRequest.class, + responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getGetGaugeMethod() { + io.grpc.MethodDescriptor getGetGaugeMethod; + if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) { + synchronized (MetricsServiceGrpc.class) { + if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) { + MetricsServiceGrpc.getGetGaugeMethod = getGetGaugeMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetGauge")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance())) + .build(); + } + } + } + return getGetGaugeMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static MetricsServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceStub(channel, callOptions); + } + }; + return MetricsServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static MetricsServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public MetricsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceBlockingStub(channel, callOptions); + } + }; + return MetricsServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static MetricsServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceFutureStub(channel, callOptions); + } + }; + return MetricsServiceFutureStub.newStub(factory, channel); + } + + /** + */ + public static abstract class MetricsServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     *
+ */ + public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getGetAllGaugesMethod(), responseObserver); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getGetGaugeMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getGetAllGaugesMethod(), + asyncServerStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Metrics.EmptyMessage, + io.grpc.testing.integration.Metrics.GaugeResponse>( + this, METHODID_GET_ALL_GAUGES))) + .addMethod( + getGetGaugeMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Metrics.GaugeRequest, + io.grpc.testing.integration.Metrics.GaugeResponse>( + this, METHODID_GET_GAUGE))) + .build(); + } + } + + /** + */ + public static final class MetricsServiceStub extends io.grpc.stub.AbstractAsyncStub { + private MetricsServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected MetricsServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceStub(channel, callOptions); + } + + /** + * 
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     *
+ */ + public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request, + io.grpc.stub.StreamObserver responseObserver) { + asyncServerStreamingCall( + getChannel().newCall(getGetAllGaugesMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + */ + public static final class MetricsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private MetricsServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected MetricsServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     *
+ */ + public java.util.Iterator getAllGauges( + io.grpc.testing.integration.Metrics.EmptyMessage request) { + return blockingServerStreamingCall( + getChannel(), getGetAllGaugesMethod(), getCallOptions(), request); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) { + return blockingUnaryCall( + getChannel(), getGetGaugeMethod(), getCallOptions(), request); + } + } + + /** + */ + public static final class MetricsServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private MetricsServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected MetricsServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture getGauge( + io.grpc.testing.integration.Metrics.GaugeRequest request) { + return futureUnaryCall( + getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_GET_ALL_GAUGES = 0; + private static final int METHODID_GET_GAUGE = 1; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final MetricsServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(MetricsServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_GET_ALL_GAUGES: + serviceImpl.getAllGauges((io.grpc.testing.integration.Metrics.EmptyMessage) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_GET_GAUGE: + serviceImpl.getGauge((io.grpc.testing.integration.Metrics.GaugeRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (MetricsServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getGetAllGaugesMethod()) + .addMethod(getGetGaugeMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java new file mode 100644 index 0000000000..832368c26e --- /dev/null +++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java @@ -0,0 +1,339 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A service used to control reconnect server.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class ReconnectServiceGrpc { + + private ReconnectServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.ReconnectService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getStartMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "Start", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getStartMethod() { + io.grpc.MethodDescriptor getStartMethod; + if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) { + synchronized (ReconnectServiceGrpc.class) { + if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) { + ReconnectServiceGrpc.getStartMethod = getStartMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Start")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getStartMethod; + } + + private static volatile io.grpc.MethodDescriptor getStopMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "Stop", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.Messages.ReconnectInfo.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getStopMethod() { + io.grpc.MethodDescriptor getStopMethod; + if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) { + synchronized (ReconnectServiceGrpc.class) { + if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) { + ReconnectServiceGrpc.getStopMethod = getStopMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Stop")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance())) + .build(); + } + } + } + return getStopMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static ReconnectServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceStub(channel, callOptions); + } + }; + return ReconnectServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static ReconnectServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public ReconnectServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceBlockingStub(channel, callOptions); + } + }; + return ReconnectServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static ReconnectServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceFutureStub(channel, callOptions); + } + }; + return ReconnectServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static abstract class ReconnectServiceImplBase implements io.grpc.BindableService { + + /** + */ + public void start(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getStartMethod(), responseObserver); + } + + /** + */ + public void stop(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getStopMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getStartMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_START))) + .addMethod( + getStopMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.Messages.ReconnectInfo>( + this, METHODID_STOP))) + .build(); + } + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static final class ReconnectServiceStub extends io.grpc.stub.AbstractAsyncStub { + private ReconnectServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected ReconnectServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceStub(channel, callOptions); + } + + /** + */ + public void start(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getStartMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void stop(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getStopMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static final class ReconnectServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private ReconnectServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected ReconnectServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceBlockingStub(channel, callOptions); + } + + /** + */ + public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getStartMethod(), getCallOptions(), request); + } + + /** + */ + public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getStopMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static final class ReconnectServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private ReconnectServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected ReconnectServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceFutureStub(channel, callOptions); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture start( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getStartMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture stop( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getStopMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_START = 0; + private static final int METHODID_STOP = 1; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final ReconnectServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(ReconnectServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_START: + serviceImpl.start((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_STOP: + serviceImpl.stop((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (ReconnectServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getStartMethod()) + .addMethod(getStopMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/TestServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/TestServiceGrpc.java new file mode 100644 index 0000000000..064eb7f757 --- /dev/null +++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/TestServiceGrpc.java @@ -0,0 +1,829 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class TestServiceGrpc { + + private TestServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.TestService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getEmptyCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "EmptyCall", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getEmptyCallMethod() { + io.grpc.MethodDescriptor getEmptyCallMethod; + if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) { + TestServiceGrpc.getEmptyCallMethod = getEmptyCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "EmptyCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getEmptyCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getUnaryCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "UnaryCall", + requestType = io.grpc.testing.integration.Messages.SimpleRequest.class, + responseType = io.grpc.testing.integration.Messages.SimpleResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getUnaryCallMethod() { + io.grpc.MethodDescriptor getUnaryCallMethod; + if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) { + TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance())) + .build(); + } + } + } + return getUnaryCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getCacheableUnaryCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "CacheableUnaryCall", + requestType = io.grpc.testing.integration.Messages.SimpleRequest.class, + responseType = io.grpc.testing.integration.Messages.SimpleResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getCacheableUnaryCallMethod() { + io.grpc.MethodDescriptor getCacheableUnaryCallMethod; + if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) { + TestServiceGrpc.getCacheableUnaryCallMethod = getCacheableUnaryCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CacheableUnaryCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance())) + .build(); + } + } + } + return getCacheableUnaryCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getStreamingOutputCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall", + requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + public static io.grpc.MethodDescriptor getStreamingOutputCallMethod() { + io.grpc.MethodDescriptor getStreamingOutputCallMethod; + if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) { + TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingOutputCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getStreamingOutputCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getStreamingInputCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall", + requestType = io.grpc.testing.integration.Messages.StreamingInputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingInputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING) + public static io.grpc.MethodDescriptor getStreamingInputCallMethod() { + io.grpc.MethodDescriptor getStreamingInputCallMethod; + if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) { + TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingInputCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getStreamingInputCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getFullDuplexCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "FullDuplexCall", + requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + public static io.grpc.MethodDescriptor getFullDuplexCallMethod() { + io.grpc.MethodDescriptor getFullDuplexCallMethod; + if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) { + TestServiceGrpc.getFullDuplexCallMethod = getFullDuplexCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FullDuplexCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getFullDuplexCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getHalfDuplexCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "HalfDuplexCall", + requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + public static io.grpc.MethodDescriptor getHalfDuplexCallMethod() { + io.grpc.MethodDescriptor getHalfDuplexCallMethod; + if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) { + TestServiceGrpc.getHalfDuplexCallMethod = getHalfDuplexCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "HalfDuplexCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getHalfDuplexCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getUnimplementedCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getUnimplementedCallMethod() { + io.grpc.MethodDescriptor getUnimplementedCallMethod; + if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) { + TestServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getUnimplementedCallMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static TestServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceStub(channel, callOptions); + } + }; + return TestServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static TestServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public TestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceBlockingStub(channel, callOptions); + } + }; + return TestServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static TestServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceFutureStub(channel, callOptions); + } + }; + return TestServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static abstract class TestServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getEmptyCallMethod(), responseObserver); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getCacheableUnaryCallMethod(), responseObserver); + } + + /** + * 
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     *
+ */ + public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver); + } + + /** + * 
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     *
+ */ + public io.grpc.stub.StreamObserver streamingInputCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver); + } + + /** + * 
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     *
+ */ + public io.grpc.stub.StreamObserver fullDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncUnimplementedStreamingCall(getFullDuplexCallMethod(), responseObserver); + } + + /** + * 
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     *
+ */ + public io.grpc.stub.StreamObserver halfDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncUnimplementedStreamingCall(getHalfDuplexCallMethod(), responseObserver); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getEmptyCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_EMPTY_CALL))) + .addMethod( + getUnaryCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.SimpleRequest, + io.grpc.testing.integration.Messages.SimpleResponse>( + this, METHODID_UNARY_CALL))) + .addMethod( + getCacheableUnaryCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.SimpleRequest, + io.grpc.testing.integration.Messages.SimpleResponse>( + this, METHODID_CACHEABLE_UNARY_CALL))) + .addMethod( + getStreamingOutputCallMethod(), + asyncServerStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingOutputCallRequest, + io.grpc.testing.integration.Messages.StreamingOutputCallResponse>( + this, METHODID_STREAMING_OUTPUT_CALL))) + .addMethod( + getStreamingInputCallMethod(), + asyncClientStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingInputCallRequest, + io.grpc.testing.integration.Messages.StreamingInputCallResponse>( + this, METHODID_STREAMING_INPUT_CALL))) + .addMethod( + getFullDuplexCallMethod(), + asyncBidiStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingOutputCallRequest, + io.grpc.testing.integration.Messages.StreamingOutputCallResponse>( + this, METHODID_FULL_DUPLEX_CALL))) + .addMethod( + getHalfDuplexCallMethod(), + asyncBidiStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingOutputCallRequest, + io.grpc.testing.integration.Messages.StreamingOutputCallResponse>( + this, METHODID_HALF_DUPLEX_CALL))) + .addMethod( + getUnimplementedCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_UNIMPLEMENTED_CALL))) + .build(); + } + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static final class TestServiceStub extends io.grpc.stub.AbstractAsyncStub { + private TestServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected TestServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceStub(channel, callOptions); + } + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     *
+ */ + public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncServerStreamingCall( + getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     *
+ */ + public io.grpc.stub.StreamObserver streamingInputCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncClientStreamingCall( + getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver); + } + + /** + * 
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     *
+ */ + public io.grpc.stub.StreamObserver fullDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncBidiStreamingCall( + getChannel().newCall(getFullDuplexCallMethod(), getCallOptions()), responseObserver); + } + + /** + * 
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     *
+ */ + public io.grpc.stub.StreamObserver halfDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncBidiStreamingCall( + getChannel().newCall(getHalfDuplexCallMethod(), getCallOptions()), responseObserver); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static final class TestServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private TestServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected TestServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getEmptyCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) { + return blockingUnaryCall( + getChannel(), getUnaryCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) { + return blockingUnaryCall( + getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     *
+ */ + public java.util.Iterator streamingOutputCall( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) { + return blockingServerStreamingCall( + getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getUnimplementedCallMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static final class TestServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private TestServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected TestServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture emptyCall( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture unaryCall( + io.grpc.testing.integration.Messages.SimpleRequest request) { + return futureUnaryCall( + getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture cacheableUnaryCall( + io.grpc.testing.integration.Messages.SimpleRequest request) { + return futureUnaryCall( + getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture unimplementedCall( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_EMPTY_CALL = 0; + private static final int METHODID_UNARY_CALL = 1; + private static final int METHODID_CACHEABLE_UNARY_CALL = 2; + private static final int METHODID_STREAMING_OUTPUT_CALL = 3; + private static final int METHODID_UNIMPLEMENTED_CALL = 4; + private static final int METHODID_STREAMING_INPUT_CALL = 5; + private static final int METHODID_FULL_DUPLEX_CALL = 6; + private static final int METHODID_HALF_DUPLEX_CALL = 7; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final TestServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(TestServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_EMPTY_CALL: + serviceImpl.emptyCall((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_UNARY_CALL: + serviceImpl.unaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_CACHEABLE_UNARY_CALL: + serviceImpl.cacheableUnaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_STREAMING_OUTPUT_CALL: + serviceImpl.streamingOutputCall((io.grpc.testing.integration.Messages.StreamingOutputCallRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_UNIMPLEMENTED_CALL: + serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_STREAMING_INPUT_CALL: + return (io.grpc.stub.StreamObserver) serviceImpl.streamingInputCall( + (io.grpc.stub.StreamObserver) responseObserver); + case METHODID_FULL_DUPLEX_CALL: + return (io.grpc.stub.StreamObserver) serviceImpl.fullDuplexCall( + (io.grpc.stub.StreamObserver) responseObserver); + case METHODID_HALF_DUPLEX_CALL: + return (io.grpc.stub.StreamObserver) serviceImpl.halfDuplexCall( + (io.grpc.stub.StreamObserver) responseObserver); + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (TestServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getEmptyCallMethod()) + .addMethod(getUnaryCallMethod()) + .addMethod(getCacheableUnaryCallMethod()) + .addMethod(getStreamingOutputCallMethod()) + .addMethod(getStreamingInputCallMethod()) + .addMethod(getFullDuplexCallMethod()) + .addMethod(getHalfDuplexCallMethod()) + .addMethod(getUnimplementedCallMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java new file mode 100644 index 0000000000..7bc4e1c5cf --- /dev/null +++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java @@ -0,0 +1,283 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class UnimplementedServiceGrpc { + + private UnimplementedServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.UnimplementedService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getUnimplementedCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getUnimplementedCallMethod() { + io.grpc.MethodDescriptor getUnimplementedCallMethod; + if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) { + synchronized (UnimplementedServiceGrpc.class) { + if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) { + UnimplementedServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getUnimplementedCallMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static UnimplementedServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceStub(channel, callOptions); + } + }; + return UnimplementedServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static UnimplementedServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public UnimplementedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceBlockingStub(channel, callOptions); + } + }; + return UnimplementedServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static UnimplementedServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceFutureStub(channel, callOptions); + } + }; + return UnimplementedServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static abstract class UnimplementedServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getUnimplementedCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_UNIMPLEMENTED_CALL))) + .build(); + } + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static final class UnimplementedServiceStub extends io.grpc.stub.AbstractAsyncStub { + private UnimplementedServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected UnimplementedServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceStub(channel, callOptions); + } + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static final class UnimplementedServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private UnimplementedServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected UnimplementedServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getUnimplementedCallMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static final class UnimplementedServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private UnimplementedServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected UnimplementedServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture unimplementedCall( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_UNIMPLEMENTED_CALL = 0; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final UnimplementedServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(UnimplementedServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_UNIMPLEMENTED_CALL: + serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (UnimplementedServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getUnimplementedCallMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java new file mode 100644 index 0000000000..26ac2a72df --- /dev/null +++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java @@ -0,0 +1,278 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A service used to obtain stats for verifying LB behavior.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class LoadBalancerStatsServiceGrpc { + + private LoadBalancerStatsServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getGetClientStatsMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetClientStats", + requestType = io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.class, + responseType = io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getGetClientStatsMethod() { + io.grpc.MethodDescriptor getGetClientStatsMethod; + if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) { + synchronized (LoadBalancerStatsServiceGrpc.class) { + if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) { + LoadBalancerStatsServiceGrpc.getGetClientStatsMethod = getGetClientStatsMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientStats")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.getDefaultInstance())) + .build(); + } + } + } + return getGetClientStatsMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceStub(channel, callOptions); + } + }; + return LoadBalancerStatsServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static LoadBalancerStatsServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public LoadBalancerStatsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceBlockingStub(channel, callOptions); + } + }; + return LoadBalancerStatsServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static LoadBalancerStatsServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceFutureStub(channel, callOptions); + } + }; + return LoadBalancerStatsServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static abstract class LoadBalancerStatsServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getGetClientStatsMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getGetClientStatsMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, + io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>( + this, METHODID_GET_CLIENT_STATS))) + .build(); + } + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static final class LoadBalancerStatsServiceStub extends io.grpc.stub.AbstractAsyncStub { + private LoadBalancerStatsServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected LoadBalancerStatsServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceStub(channel, callOptions); + } + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static final class LoadBalancerStatsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private LoadBalancerStatsServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected LoadBalancerStatsServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) { + return blockingUnaryCall( + getChannel(), getGetClientStatsMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A service used to obtain stats for verifying LB behavior.
+   *
+ */ + public static final class LoadBalancerStatsServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private LoadBalancerStatsServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected LoadBalancerStatsServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new LoadBalancerStatsServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * Gets the backend distribution for RPCs sent by a test client.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture getClientStats( + io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) { + return futureUnaryCall( + getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_GET_CLIENT_STATS = 0; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final LoadBalancerStatsServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(LoadBalancerStatsServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_GET_CLIENT_STATS: + serviceImpl.getClientStats((io.grpc.testing.integration.Messages.LoadBalancerStatsRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (LoadBalancerStatsServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getGetClientStatsMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java new file mode 100644 index 0000000000..470c3bcee0 --- /dev/null +++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java @@ -0,0 +1,341 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/metrics.proto") +public final class MetricsServiceGrpc { + + private MetricsServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.MetricsService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getGetAllGaugesMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetAllGauges", + requestType = io.grpc.testing.integration.Metrics.EmptyMessage.class, + responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + public static io.grpc.MethodDescriptor getGetAllGaugesMethod() { + io.grpc.MethodDescriptor getGetAllGaugesMethod; + if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) { + synchronized (MetricsServiceGrpc.class) { + if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) { + MetricsServiceGrpc.getGetAllGaugesMethod = getGetAllGaugesMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAllGauges")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance())) + .build(); + } + } + } + return getGetAllGaugesMethod; + } + + private static volatile io.grpc.MethodDescriptor getGetGaugeMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetGauge", + requestType = io.grpc.testing.integration.Metrics.GaugeRequest.class, + responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getGetGaugeMethod() { + io.grpc.MethodDescriptor getGetGaugeMethod; + if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) { + synchronized (MetricsServiceGrpc.class) { + if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) { + MetricsServiceGrpc.getGetGaugeMethod = getGetGaugeMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetGauge")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance())) + .build(); + } + } + } + return getGetGaugeMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static MetricsServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceStub(channel, callOptions); + } + }; + return MetricsServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static MetricsServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public MetricsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceBlockingStub(channel, callOptions); + } + }; + return MetricsServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static MetricsServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceFutureStub(channel, callOptions); + } + }; + return MetricsServiceFutureStub.newStub(factory, channel); + } + + /** + */ + public static abstract class MetricsServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     *
+ */ + public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getGetAllGaugesMethod(), responseObserver); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getGetGaugeMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getGetAllGaugesMethod(), + asyncServerStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Metrics.EmptyMessage, + io.grpc.testing.integration.Metrics.GaugeResponse>( + this, METHODID_GET_ALL_GAUGES))) + .addMethod( + getGetGaugeMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Metrics.GaugeRequest, + io.grpc.testing.integration.Metrics.GaugeResponse>( + this, METHODID_GET_GAUGE))) + .build(); + } + } + + /** + */ + public static final class MetricsServiceStub extends io.grpc.stub.AbstractAsyncStub { + private MetricsServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected MetricsServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceStub(channel, callOptions); + } + + /** + * 
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     *
+ */ + public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request, + io.grpc.stub.StreamObserver responseObserver) { + asyncServerStreamingCall( + getChannel().newCall(getGetAllGaugesMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + */ + public static final class MetricsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private MetricsServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected MetricsServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     *
+ */ + public java.util.Iterator getAllGauges( + io.grpc.testing.integration.Metrics.EmptyMessage request) { + return blockingServerStreamingCall( + getChannel(), getGetAllGaugesMethod(), getCallOptions(), request); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) { + return blockingUnaryCall( + getChannel(), getGetGaugeMethod(), getCallOptions(), request); + } + } + + /** + */ + public static final class MetricsServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private MetricsServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected MetricsServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new MetricsServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * Returns the value of one gauge
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture getGauge( + io.grpc.testing.integration.Metrics.GaugeRequest request) { + return futureUnaryCall( + getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_GET_ALL_GAUGES = 0; + private static final int METHODID_GET_GAUGE = 1; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final MetricsServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(MetricsServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_GET_ALL_GAUGES: + serviceImpl.getAllGauges((io.grpc.testing.integration.Metrics.EmptyMessage) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_GET_GAUGE: + serviceImpl.getGauge((io.grpc.testing.integration.Metrics.GaugeRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (MetricsServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getGetAllGaugesMethod()) + .addMethod(getGetGaugeMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java new file mode 100644 index 0000000000..832368c26e --- /dev/null +++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java @@ -0,0 +1,339 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A service used to control reconnect server.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class ReconnectServiceGrpc { + + private ReconnectServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.ReconnectService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getStartMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "Start", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getStartMethod() { + io.grpc.MethodDescriptor getStartMethod; + if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) { + synchronized (ReconnectServiceGrpc.class) { + if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) { + ReconnectServiceGrpc.getStartMethod = getStartMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Start")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getStartMethod; + } + + private static volatile io.grpc.MethodDescriptor getStopMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "Stop", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.Messages.ReconnectInfo.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getStopMethod() { + io.grpc.MethodDescriptor getStopMethod; + if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) { + synchronized (ReconnectServiceGrpc.class) { + if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) { + ReconnectServiceGrpc.getStopMethod = getStopMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Stop")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance())) + .build(); + } + } + } + return getStopMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static ReconnectServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceStub(channel, callOptions); + } + }; + return ReconnectServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static ReconnectServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public ReconnectServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceBlockingStub(channel, callOptions); + } + }; + return ReconnectServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static ReconnectServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceFutureStub(channel, callOptions); + } + }; + return ReconnectServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static abstract class ReconnectServiceImplBase implements io.grpc.BindableService { + + /** + */ + public void start(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getStartMethod(), responseObserver); + } + + /** + */ + public void stop(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getStopMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getStartMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_START))) + .addMethod( + getStopMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.Messages.ReconnectInfo>( + this, METHODID_STOP))) + .build(); + } + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static final class ReconnectServiceStub extends io.grpc.stub.AbstractAsyncStub { + private ReconnectServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected ReconnectServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceStub(channel, callOptions); + } + + /** + */ + public void start(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getStartMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void stop(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getStopMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static final class ReconnectServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private ReconnectServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected ReconnectServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceBlockingStub(channel, callOptions); + } + + /** + */ + public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getStartMethod(), getCallOptions(), request); + } + + /** + */ + public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getStopMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A service used to control reconnect server.
+   *
+ */ + public static final class ReconnectServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private ReconnectServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected ReconnectServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new ReconnectServiceFutureStub(channel, callOptions); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture start( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getStartMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture stop( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getStopMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_START = 0; + private static final int METHODID_STOP = 1; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final ReconnectServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(ReconnectServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_START: + serviceImpl.start((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_STOP: + serviceImpl.stop((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (ReconnectServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getStartMethod()) + .addMethod(getStopMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/TestServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/TestServiceGrpc.java new file mode 100644 index 0000000000..064eb7f757 --- /dev/null +++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/TestServiceGrpc.java @@ -0,0 +1,829 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class TestServiceGrpc { + + private TestServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.TestService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getEmptyCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "EmptyCall", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getEmptyCallMethod() { + io.grpc.MethodDescriptor getEmptyCallMethod; + if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) { + TestServiceGrpc.getEmptyCallMethod = getEmptyCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "EmptyCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getEmptyCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getUnaryCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "UnaryCall", + requestType = io.grpc.testing.integration.Messages.SimpleRequest.class, + responseType = io.grpc.testing.integration.Messages.SimpleResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getUnaryCallMethod() { + io.grpc.MethodDescriptor getUnaryCallMethod; + if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) { + TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance())) + .build(); + } + } + } + return getUnaryCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getCacheableUnaryCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "CacheableUnaryCall", + requestType = io.grpc.testing.integration.Messages.SimpleRequest.class, + responseType = io.grpc.testing.integration.Messages.SimpleResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getCacheableUnaryCallMethod() { + io.grpc.MethodDescriptor getCacheableUnaryCallMethod; + if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) { + TestServiceGrpc.getCacheableUnaryCallMethod = getCacheableUnaryCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CacheableUnaryCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance())) + .build(); + } + } + } + return getCacheableUnaryCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getStreamingOutputCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall", + requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + public static io.grpc.MethodDescriptor getStreamingOutputCallMethod() { + io.grpc.MethodDescriptor getStreamingOutputCallMethod; + if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) { + TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingOutputCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getStreamingOutputCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getStreamingInputCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall", + requestType = io.grpc.testing.integration.Messages.StreamingInputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingInputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING) + public static io.grpc.MethodDescriptor getStreamingInputCallMethod() { + io.grpc.MethodDescriptor getStreamingInputCallMethod; + if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) { + TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingInputCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getStreamingInputCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getFullDuplexCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "FullDuplexCall", + requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + public static io.grpc.MethodDescriptor getFullDuplexCallMethod() { + io.grpc.MethodDescriptor getFullDuplexCallMethod; + if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) { + TestServiceGrpc.getFullDuplexCallMethod = getFullDuplexCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FullDuplexCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getFullDuplexCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getHalfDuplexCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "HalfDuplexCall", + requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, + responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + public static io.grpc.MethodDescriptor getHalfDuplexCallMethod() { + io.grpc.MethodDescriptor getHalfDuplexCallMethod; + if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) { + TestServiceGrpc.getHalfDuplexCallMethod = getHalfDuplexCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "HalfDuplexCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance())) + .build(); + } + } + } + return getHalfDuplexCallMethod; + } + + private static volatile io.grpc.MethodDescriptor getUnimplementedCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getUnimplementedCallMethod() { + io.grpc.MethodDescriptor getUnimplementedCallMethod; + if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) { + synchronized (TestServiceGrpc.class) { + if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) { + TestServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getUnimplementedCallMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static TestServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceStub(channel, callOptions); + } + }; + return TestServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static TestServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public TestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceBlockingStub(channel, callOptions); + } + }; + return TestServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static TestServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceFutureStub(channel, callOptions); + } + }; + return TestServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static abstract class TestServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getEmptyCallMethod(), responseObserver); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getCacheableUnaryCallMethod(), responseObserver); + } + + /** + * 
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     *
+ */ + public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver); + } + + /** + * 
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     *
+ */ + public io.grpc.stub.StreamObserver streamingInputCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver); + } + + /** + * 
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     *
+ */ + public io.grpc.stub.StreamObserver fullDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncUnimplementedStreamingCall(getFullDuplexCallMethod(), responseObserver); + } + + /** + * 
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     *
+ */ + public io.grpc.stub.StreamObserver halfDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncUnimplementedStreamingCall(getHalfDuplexCallMethod(), responseObserver); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getEmptyCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_EMPTY_CALL))) + .addMethod( + getUnaryCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.SimpleRequest, + io.grpc.testing.integration.Messages.SimpleResponse>( + this, METHODID_UNARY_CALL))) + .addMethod( + getCacheableUnaryCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.SimpleRequest, + io.grpc.testing.integration.Messages.SimpleResponse>( + this, METHODID_CACHEABLE_UNARY_CALL))) + .addMethod( + getStreamingOutputCallMethod(), + asyncServerStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingOutputCallRequest, + io.grpc.testing.integration.Messages.StreamingOutputCallResponse>( + this, METHODID_STREAMING_OUTPUT_CALL))) + .addMethod( + getStreamingInputCallMethod(), + asyncClientStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingInputCallRequest, + io.grpc.testing.integration.Messages.StreamingInputCallResponse>( + this, METHODID_STREAMING_INPUT_CALL))) + .addMethod( + getFullDuplexCallMethod(), + asyncBidiStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingOutputCallRequest, + io.grpc.testing.integration.Messages.StreamingOutputCallResponse>( + this, METHODID_FULL_DUPLEX_CALL))) + .addMethod( + getHalfDuplexCallMethod(), + asyncBidiStreamingCall( + new MethodHandlers< + io.grpc.testing.integration.Messages.StreamingOutputCallRequest, + io.grpc.testing.integration.Messages.StreamingOutputCallResponse>( + this, METHODID_HALF_DUPLEX_CALL))) + .addMethod( + getUnimplementedCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_UNIMPLEMENTED_CALL))) + .build(); + } + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static final class TestServiceStub extends io.grpc.stub.AbstractAsyncStub { + private TestServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected TestServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceStub(channel, callOptions); + } + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     *
+ */ + public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request, + io.grpc.stub.StreamObserver responseObserver) { + asyncServerStreamingCall( + getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver); + } + + /** + * 
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     *
+ */ + public io.grpc.stub.StreamObserver streamingInputCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncClientStreamingCall( + getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver); + } + + /** + * 
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     *
+ */ + public io.grpc.stub.StreamObserver fullDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncBidiStreamingCall( + getChannel().newCall(getFullDuplexCallMethod(), getCallOptions()), responseObserver); + } + + /** + * 
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     *
+ */ + public io.grpc.stub.StreamObserver halfDuplexCall( + io.grpc.stub.StreamObserver responseObserver) { + return asyncBidiStreamingCall( + getChannel().newCall(getHalfDuplexCallMethod(), getCallOptions()), responseObserver); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static final class TestServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private TestServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected TestServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getEmptyCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) { + return blockingUnaryCall( + getChannel(), getUnaryCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) { + return blockingUnaryCall( + getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     *
+ */ + public java.util.Iterator streamingOutputCall( + io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) { + return blockingServerStreamingCall( + getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getUnimplementedCallMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   *
+ */ + public static final class TestServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private TestServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected TestServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new TestServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * One empty request followed by one empty response.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture emptyCall( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request); + } + + /** + * 
+     * One request followed by one response.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture unaryCall( + io.grpc.testing.integration.Messages.SimpleRequest request) { + return futureUnaryCall( + getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request); + } + + /** + * 
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture cacheableUnaryCall( + io.grpc.testing.integration.Messages.SimpleRequest request) { + return futureUnaryCall( + getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request); + } + + /** + * 
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture unimplementedCall( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_EMPTY_CALL = 0; + private static final int METHODID_UNARY_CALL = 1; + private static final int METHODID_CACHEABLE_UNARY_CALL = 2; + private static final int METHODID_STREAMING_OUTPUT_CALL = 3; + private static final int METHODID_UNIMPLEMENTED_CALL = 4; + private static final int METHODID_STREAMING_INPUT_CALL = 5; + private static final int METHODID_FULL_DUPLEX_CALL = 6; + private static final int METHODID_HALF_DUPLEX_CALL = 7; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final TestServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(TestServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_EMPTY_CALL: + serviceImpl.emptyCall((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_UNARY_CALL: + serviceImpl.unaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_CACHEABLE_UNARY_CALL: + serviceImpl.cacheableUnaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_STREAMING_OUTPUT_CALL: + serviceImpl.streamingOutputCall((io.grpc.testing.integration.Messages.StreamingOutputCallRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_UNIMPLEMENTED_CALL: + serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_STREAMING_INPUT_CALL: + return (io.grpc.stub.StreamObserver) serviceImpl.streamingInputCall( + (io.grpc.stub.StreamObserver) responseObserver); + case METHODID_FULL_DUPLEX_CALL: + return (io.grpc.stub.StreamObserver) serviceImpl.fullDuplexCall( + (io.grpc.stub.StreamObserver) responseObserver); + case METHODID_HALF_DUPLEX_CALL: + return (io.grpc.stub.StreamObserver) serviceImpl.halfDuplexCall( + (io.grpc.stub.StreamObserver) responseObserver); + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (TestServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getEmptyCallMethod()) + .addMethod(getUnaryCallMethod()) + .addMethod(getCacheableUnaryCallMethod()) + .addMethod(getStreamingOutputCallMethod()) + .addMethod(getStreamingInputCallMethod()) + .addMethod(getFullDuplexCallMethod()) + .addMethod(getHalfDuplexCallMethod()) + .addMethod(getUnimplementedCallMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java new file mode 100644 index 0000000000..7bc4e1c5cf --- /dev/null +++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java @@ -0,0 +1,283 @@ +package io.grpc.testing.integration; + +import static io.grpc.MethodDescriptor.generateFullMethodName; +import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; +import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; +import static io.grpc.stub.ClientCalls.asyncUnaryCall; +import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; +import static io.grpc.stub.ClientCalls.blockingUnaryCall; +import static io.grpc.stub.ClientCalls.futureUnaryCall; +import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; +import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; +import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnaryCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; +import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; + +/** + * 
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ *
+ */ +@javax.annotation.Generated( + value = "by gRPC proto compiler", + comments = "Source: grpc/testing/test.proto") +public final class UnimplementedServiceGrpc { + + private UnimplementedServiceGrpc() {} + + public static final String SERVICE_NAME = "grpc.testing.UnimplementedService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getUnimplementedCallMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall", + requestType = io.grpc.testing.integration.EmptyProtos.Empty.class, + responseType = io.grpc.testing.integration.EmptyProtos.Empty.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getUnimplementedCallMethod() { + io.grpc.MethodDescriptor getUnimplementedCallMethod; + if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) { + synchronized (UnimplementedServiceGrpc.class) { + if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) { + UnimplementedServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller( + io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance())) + .build(); + } + } + } + return getUnimplementedCallMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static UnimplementedServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceStub(channel, callOptions); + } + }; + return UnimplementedServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static UnimplementedServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public UnimplementedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceBlockingStub(channel, callOptions); + } + }; + return UnimplementedServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static UnimplementedServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceFutureStub(channel, callOptions); + } + }; + return UnimplementedServiceFutureStub.newStub(factory, channel); + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static abstract class UnimplementedServiceImplBase implements io.grpc.BindableService { + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver); + } + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getUnimplementedCallMethod(), + asyncUnaryCall( + new MethodHandlers< + io.grpc.testing.integration.EmptyProtos.Empty, + io.grpc.testing.integration.EmptyProtos.Empty>( + this, METHODID_UNIMPLEMENTED_CALL))) + .build(); + } + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static final class UnimplementedServiceStub extends io.grpc.stub.AbstractAsyncStub { + private UnimplementedServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected UnimplementedServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceStub(channel, callOptions); + } + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request, + io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static final class UnimplementedServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private UnimplementedServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected UnimplementedServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceBlockingStub(channel, callOptions); + } + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) { + return blockingUnaryCall( + getChannel(), getUnimplementedCallMethod(), getCallOptions(), request); + } + } + + /** + * 
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   *
+ */ + public static final class UnimplementedServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private UnimplementedServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected UnimplementedServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new UnimplementedServiceFutureStub(channel, callOptions); + } + + /** + * 
+     * A call that no server should implement
+     *
+ */ + public com.google.common.util.concurrent.ListenableFuture unimplementedCall( + io.grpc.testing.integration.EmptyProtos.Empty request) { + return futureUnaryCall( + getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_UNIMPLEMENTED_CALL = 0; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final UnimplementedServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(UnimplementedServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_UNIMPLEMENTED_CALL: + serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (UnimplementedServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .addMethod(getUnimplementedCallMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/android-interop-testing/app/src/main/AndroidManifest.xml b/android-interop-testing/src/main/AndroidManifest.xml similarity index 91% rename from android-interop-testing/app/src/main/AndroidManifest.xml rename to android-interop-testing/src/main/AndroidManifest.xml index cb9f81e242..10f865ad69 100644 --- a/android-interop-testing/app/src/main/AndroidManifest.xml +++ b/android-interop-testing/src/main/AndroidManifest.xml @@ -3,9 +3,7 @@ package="io.grpc.android.integrationtest" > - + diff --git a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/InteropTask.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/InteropTask.java similarity index 99% rename from android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/InteropTask.java rename to android-interop-testing/src/main/java/io/grpc/android/integrationtest/InteropTask.java index caeafb723d..993a62555f 100644 --- a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/InteropTask.java +++ b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/InteropTask.java @@ -145,7 +145,6 @@ final class InteropTask extends AsyncTask { } private static class Tester extends AbstractInteropTest { - private final ManagedChannel channel; private Tester(ManagedChannel channel) { this.channel = channel; diff --git a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterActivity.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterActivity.java similarity index 98% rename from android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterActivity.java rename to android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterActivity.java index 4081439f23..004950e738 100644 --- a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterActivity.java +++ b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterActivity.java @@ -31,7 +31,7 @@ import android.widget.TextView; import com.google.android.gms.security.ProviderInstaller; import io.grpc.ManagedChannel; import java.io.InputStream; -import java.util.LinkedList; +import java.util.ArrayList; import java.util.List; public class TesterActivity extends AppCompatActivity @@ -48,7 +48,7 @@ public class TesterActivity extends AppCompatActivity protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_tester); - buttons = new LinkedList<>(); + buttons = new ArrayList<>(); buttons.add((Button) findViewById(R.id.empty_unary_button)); buttons.add((Button) findViewById(R.id.large_unary_button)); buttons.add((Button) findViewById(R.id.client_streaming_button)); diff --git a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java similarity index 100% rename from android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java rename to android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java diff --git a/android-interop-testing/app/src/main/res/layout/activity_tester.xml b/android-interop-testing/src/main/res/layout/activity_tester.xml similarity index 100% rename from android-interop-testing/app/src/main/res/layout/activity_tester.xml rename to android-interop-testing/src/main/res/layout/activity_tester.xml diff --git a/android-interop-testing/app/src/main/res/mipmap-hdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-hdpi/ic_launcher.png similarity index 100% rename from android-interop-testing/app/src/main/res/mipmap-hdpi/ic_launcher.png rename to android-interop-testing/src/main/res/mipmap-hdpi/ic_launcher.png diff --git a/android-interop-testing/app/src/main/res/mipmap-mdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-mdpi/ic_launcher.png similarity index 100% rename from android-interop-testing/app/src/main/res/mipmap-mdpi/ic_launcher.png rename to android-interop-testing/src/main/res/mipmap-mdpi/ic_launcher.png diff --git a/android-interop-testing/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-xhdpi/ic_launcher.png similarity index 100% rename from android-interop-testing/app/src/main/res/mipmap-xhdpi/ic_launcher.png rename to android-interop-testing/src/main/res/mipmap-xhdpi/ic_launcher.png diff --git a/android-interop-testing/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-xxhdpi/ic_launcher.png similarity index 100% rename from android-interop-testing/app/src/main/res/mipmap-xxhdpi/ic_launcher.png rename to android-interop-testing/src/main/res/mipmap-xxhdpi/ic_launcher.png diff --git a/android-interop-testing/app/src/main/res/raw/ca.pem b/android-interop-testing/src/main/res/raw/ca.pem similarity index 100% rename from android-interop-testing/app/src/main/res/raw/ca.pem rename to android-interop-testing/src/main/res/raw/ca.pem diff --git a/android-interop-testing/app/src/main/res/values/strings.xml b/android-interop-testing/src/main/res/values/strings.xml similarity index 100% rename from android-interop-testing/app/src/main/res/values/strings.xml rename to android-interop-testing/src/main/res/values/strings.xml diff --git a/build.gradle b/build.gradle index ecb5c7e011..5ad1a222d7 100644 --- a/build.gradle +++ b/build.gradle @@ -1,5 +1,6 @@ plugins { - id "com.android.library" apply false // Necessary for Android plugin to find its classes + id "com.android.application" apply false // Necessary for Android plugin to find its classes + id "com.android.library" apply false id "com.google.osdetector" apply false id "me.champeau.gradle.japicmp" apply false id "net.ltgt.errorprone" apply false @@ -53,6 +54,7 @@ subprojects { opencensusVersion = '0.24.0' configureProtoCompilation = { + boolean isAndroid = project.getName().contains('android') String generatedSourcePath = "${projectDir}/src/generated" project.protobuf { protoc { @@ -67,41 +69,57 @@ subprojects { // Recompile protos when build.gradle has been changed, because // it's possible the version of protoc has been changed. task.inputs.file "${rootProject.projectDir}/build.gradle" + if (isAndroid) { + task.builtins { + java { option 'lite' } + } + } } } } if (rootProject.childProjects.containsKey('grpc-compiler')) { // Only when the codegen is built along with the project, will we be able to run // the grpc code generator. + task syncGeneratedSources { } project.protobuf { plugins { grpc { path = javaPluginPath } } generateProtoTasks { all().each { task -> - project["syncGeneratedSources${task.sourceSet.name}"].dependsOn task + String variantOrSourceSet = isAndroid ? task.variant.name : task.sourceSet.name + def syncTask = project.tasks.register("syncGeneratedSources${variantOrSourceSet}", Sync) { + from "$buildDir/generated/source/proto/${variantOrSourceSet}/grpc" + into "$generatedSourcePath/${variantOrSourceSet}/grpc" + } + syncGeneratedSources.dependsOn syncTask task.dependsOn ':grpc-compiler:java_pluginExecutable' // Recompile protos when the codegen has been changed task.inputs.file javaPluginPath task.plugins { grpc { option 'noversion' } } + if (isAndroid) { + task.plugins { + grpc { + option 'lite' + } + } + } } } } - - task syncGeneratedSources { } - sourceSets.all { sourceSet -> - task "syncGeneratedSources${sourceSet.name}"(type: Sync) { - from "$buildDir/generated/source/proto/${sourceSet.name}/grpc" - into "$generatedSourcePath/${sourceSet.name}/grpc" - } - syncGeneratedSources.dependsOn "syncGeneratedSources${sourceSet.name}" - } // Re-sync as part of a normal build, to avoid forgetting to run the sync assemble.dependsOn syncGeneratedSources } else { // Otherwise, we just use the checked-in generated code. - project.sourceSets { - main { java { srcDir "${generatedSourcePath}/main/grpc" } } - test { java { srcDir "${generatedSourcePath}/test/grpc" } } + if (isAndroid) { + project.android.sourceSets { + debug { java { srcDir "${generatedSourcePath}/debug/grpc" } } + release { java { srcDir "${generatedSourcePath}/release/grpc" } } + } + } else { + project.sourceSets { + main { java { srcDir "${generatedSourcePath}/main/grpc" } } + test { java { srcDir "${generatedSourcePath}/test/grpc" } } + } } } diff --git a/settings.gradle b/settings.gradle index fdac9730f4..8f7c8d4dfb 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,5 +1,6 @@ pluginManagement { plugins { + id "com.android.application" version "3.3.0" id "com.android.library" version "3.3.0" id "com.github.johnrengelman.shadow" version "2.0.4" id "com.github.kt3k.coveralls" version "2.0.1" @@ -88,4 +89,6 @@ if (settings.hasProperty('skipAndroid') && skipAndroid.toBoolean()) { project(':grpc-cronet').projectDir = "$rootDir/cronet" as File include ":grpc-android" project(':grpc-android').projectDir = "$rootDir/android" as File + include ":grpc-android-interop-testing" + project(':grpc-android-interop-testing').projectDir = "$rootDir/android-interop-testing" as File }