STRLCPY/tsunami-security-scanner

Add ListPlugins RPC protocol handler.

PiperOrigin-RevId: 460545504
Change-Id: Id57bdcc1c9e7708d95b23e49b9d7aa6bcc6625ab

John Y. Kim committed with Copybara-Service 2 years ago

59fcb57b

1 parent 094dcf00

Total 4 files Show one by one

■ ■ ■ ■ ■ ■

build.gradle

		skipped 61 lines
62	62		guice: "com.google.inject:guice:${guiceVersion}",
63	63		guice_assisted: "com.google.inject.extensions:guice-assistedinject:${guiceVersion}",
64	64		grpc_protobuf: "io.grpc:grpc-protobuf:${grpcVersion}",
	65	+	grpc_context: "io.grpc:grpc-context:${grpcVersion}",
65	66		grpc_stub: "io.grpc:grpc-stub:${grpcVersion}",
66	67		grpc_core: "io.grpc:grpc-core:${grpcVersion}",
67	68		grpc_testing: "io.grpc:grpc-testing:${grpcVersion}",
		skipped 157 lines

■ ■ ■ ■ ■ ■

plugin/build.gradle

		skipped 15 lines
16	16		compile deps.protobuf_util
17	17		compile deps.grpc_core
18	18		compile deps.grpc_testing
	19	+	compile deps.grpc_context
19	20		compile deps.tcs_common, deps.tcs_proto
20	21		annotationProcessor deps.autovalue_annotation_processor
21	22
		skipped 6 lines

■ ■ ■ ■ ■ ■

plugin/src/main/java/com/google/tsunami/plugin/PluginServiceClient.java

		skipped 16 lines
17	17
18	18		import static com.google.common.base.Preconditions.checkNotNull;
19	19
20		-	import com.google.common.util.concurrent.Futures;
21	20		import com.google.common.util.concurrent.ListenableFuture;
22		-	import com.google.common.util.concurrent.ListeningScheduledExecutorService;
	21	+	import com.google.tsunami.proto.ListPluginsRequest;
	22	+	import com.google.tsunami.proto.ListPluginsResponse;
23	23		import com.google.tsunami.proto.PluginServiceGrpc;
24	24		import com.google.tsunami.proto.PluginServiceGrpc.PluginServiceFutureStub;
25	25		import com.google.tsunami.proto.RunRequest;
26	26		import com.google.tsunami.proto.RunResponse;
27	27		import io.grpc.Channel;
28		-	import java.time.Duration;
	28	+	import io.grpc.Deadline;
29	29
30	30		/**
31	31		* Client side gRPC handler for the PluginService RPC protocol. Main handler for all gRPC calls to
		skipped 2 lines
34	34		public final class PluginServiceClient {
35	35
36	36		private final PluginServiceFutureStub pluginService;
37		-	private final ListeningScheduledExecutorService scheduledExecutorService;
38	37
39		-	PluginServiceClient(Channel channel, ListeningScheduledExecutorService service) {
	38	+	PluginServiceClient(Channel channel) {
40	39		this.pluginService = PluginServiceGrpc.newFutureStub(checkNotNull(channel));
41		-	this.scheduledExecutorService = checkNotNull(service);
42	40		}
43	41
44	42		/**
		skipped 3 lines
48	46		* @param deadline The timeout of the service.
49	47		* @return The future of the run response.
50	48		*/
51		-	public ListenableFuture<RunResponse> runWithDeadline(RunRequest request, Duration deadline) {
52		-	return Futures.withTimeout(pluginService.run(request), deadline, scheduledExecutorService);
	49	+	public ListenableFuture<RunResponse> runWithDeadline(RunRequest request, Deadline deadline) {
	50	+	return pluginService.withDeadline(deadline).run(request);
	51	+	}
	52	+
	53	+	/**
	54	+	* Sends a list plugins request to the gRPC language server with a specified deadline.
	55	+	*
	56	+	* @param request The main request to notify the language server to send their plugins.
	57	+	* @param deadline The timeout of the service.
	58	+	* @return The future of the run response.
	59	+	*/
	60	+	public ListenableFuture<ListPluginsResponse> listPluginsWithDeadline(
	61	+	ListPluginsRequest request, Deadline deadline) {
	62	+	return pluginService.withDeadline(deadline).listPlugins(request);
53	63		}
54	64		}
55	65

■ ■ ■ ■ ■ ■

plugin/src/test/java/com/google/tsunami/plugin/PluginServiceClientTest.java

		skipped 15 lines
16	16		package com.google.tsunami.plugin;
17	17
18	18		import static com.google.common.truth.Truth.assertThat;
	19	+	import static java.util.concurrent.TimeUnit.SECONDS;
19	20
	21	+	import com.google.common.collect.Lists;
20	22		import com.google.common.util.concurrent.ListenableFuture;
21		-	import com.google.common.util.concurrent.ListeningScheduledExecutorService;
22		-	import com.google.inject.Guice;
23		-	import com.google.inject.Key;
24		-	import com.google.tsunami.common.concurrent.ScheduledThreadPoolModule;
25	23		import com.google.tsunami.common.data.NetworkEndpointUtils;
26	24		import com.google.tsunami.proto.DetectionReport;
27	25		import com.google.tsunami.proto.DetectionReportList;
	26	+	import com.google.tsunami.proto.ListPluginsRequest;
	27	+	import com.google.tsunami.proto.ListPluginsResponse;
28	28		import com.google.tsunami.proto.MatchedPlugin;
29	29		import com.google.tsunami.proto.NetworkEndpoint;
30	30		import com.google.tsunami.proto.NetworkService;
		skipped 4 lines
35	35		import com.google.tsunami.proto.RunResponse;
36	36		import com.google.tsunami.proto.TargetInfo;
37	37		import com.google.tsunami.proto.TransportProtocol;
	38	+	import io.grpc.Deadline;
38	39		import io.grpc.inprocess.InProcessChannelBuilder;
39	40		import io.grpc.inprocess.InProcessServerBuilder;
40	41		import io.grpc.stub.StreamObserver;
41	42		import io.grpc.testing.GrpcCleanupRule;
42	43		import io.grpc.util.MutableHandlerRegistry;
43		-	import java.lang.annotation.Retention;
44		-	import java.lang.annotation.RetentionPolicy;
45		-	import java.time.Duration;
46	44		import java.util.ArrayList;
47	45		import java.util.List;
48		-	import javax.inject.Qualifier;
49	46		import org.junit.Before;
50	47		import org.junit.Rule;
51	48		import org.junit.Test;
		skipped 4 lines
56	53		@RunWith(JUnit4.class)
57	54		public final class PluginServiceClientTest {
58	55
59		-	// TODO(b/236740807): Create a wrapper for results and errors.
60		-
61		-	// Useful test thread pool used for testing grpc handlers
62		-	@Qualifier
63		-	@Retention(RetentionPolicy.RUNTIME)
64		-	@interface TestThreadPool {}
65		-
66	56		@Rule public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
67	57
68		-	private static final int THREAD_POOLS = 1;
69		-	private static final String THREAD_POOL_NAME = "test";
70		-
71	58		private static final String PLUGIN_NAME = "test plugin";
72	59		private static final String PLUGIN_VERSION = "0.0.1";
73	60		private static final String PLUGIN_DESCRIPTION = "test description";
74	61		private static final String PLUGIN_AUTHOR = "tester";
75	62
76		-	private static final Duration DURATION_DEFAULT = Duration.ofSeconds(1);
	63	+	private static final Deadline DEADLINE_DEFAULT = Deadline.after(1, SECONDS);
77	64
78	65		private PluginServiceClient pluginService;
79	66		private final MutableHandlerRegistry serviceRegistry = new MutableHandlerRegistry();
		skipped 10 lines
90	77
91	78		pluginService =
92	79		new PluginServiceClient(
93		-	InProcessChannelBuilder.forName(serverName).directExecutor().build(),
94		-	Guice.createInjector(
95		-	new ScheduledThreadPoolModule.Builder()
96		-	.setName(THREAD_POOL_NAME)
97		-	.setSize(THREAD_POOLS)
98		-	.setAnnotation(TestThreadPool.class)
99		-	.build())
100		-	.getInstance(
101		-	Key.get(ListeningScheduledExecutorService.class, TestThreadPool.class)));
	80	+	InProcessChannelBuilder.forName(serverName).directExecutor().build());
102	81		}
103	82
104	83		@Test
		skipped 14 lines
119	98		};
120	99		serviceRegistry.addService(runImpl);
121	100
122		-	ListenableFuture<RunResponse> run = pluginService.runWithDeadline(runRequest, DURATION_DEFAULT);
	101	+	ListenableFuture<RunResponse> run = pluginService.runWithDeadline(runRequest, DEADLINE_DEFAULT);
123	102		RunResponse runResponse = run.get();
124	103
125	104		assertThat(run.isDone()).isTrue();
		skipped 20 lines
146	125		};
147	126		serviceRegistry.addService(runImpl);
148	127
149		-	ListenableFuture<RunResponse> run = pluginService.runWithDeadline(runRequest, DURATION_DEFAULT);
	128	+	ListenableFuture<RunResponse> run = pluginService.runWithDeadline(runRequest, DEADLINE_DEFAULT);
150	129		RunResponse runResponse = run.get();
151	130
152	131		assertThat(run.isDone()).isTrue();
		skipped 55 lines
208	187		};
209	188		serviceRegistry.addService(runImpl);
210	189
211		-	ListenableFuture<RunResponse> run = pluginService.runWithDeadline(runRequest, DURATION_DEFAULT);
	190	+	ListenableFuture<RunResponse> run = pluginService.runWithDeadline(runRequest, DEADLINE_DEFAULT);
212	191		RunResponse runResponse = run.get();
213	192
214	193		assertThat(run.isDone()).isTrue();
		skipped 1 lines
216	195		assertRunResponseContainsAllRunRequestParameters(runResponse, runRequest);
217	196		}
218	197
	198	+	@Test
	199	+	public void listPlugins_returnsMultiplePlugins() throws Exception {
	200	+	ListPluginsRequest request = ListPluginsRequest.getDefaultInstance();
	201	+
	202	+	List<PluginDefinition> plugins = Lists.newArrayList();
	203	+	for (int i = 0; i < 5; i++) {
	204	+	plugins.add(createSinglePluginDefinitionWithName(String.format(PLUGIN_NAME + "%d", i)));
	205	+	}
	206	+
	207	+	PluginServiceImplBase listPluginsImpl =
	208	+	new PluginServiceImplBase() {
	209	+	@Override
	210	+	public void listPlugins(
	211	+	ListPluginsRequest request, StreamObserver<ListPluginsResponse> responseObserver) {
	212	+	responseObserver.onNext(
	213	+	ListPluginsResponse.newBuilder().addAllPlugins(plugins).build());
	214	+	responseObserver.onCompleted();
	215	+	}
	216	+	};
	217	+	serviceRegistry.addService(listPluginsImpl);
	218	+
	219	+	ListenableFuture<ListPluginsResponse> listPlugins =
	220	+	pluginService.listPluginsWithDeadline(request, DEADLINE_DEFAULT);
	221	+
	222	+	assertThat(listPlugins.isDone()).isTrue();
	223	+	assertThat(listPlugins.get().getPluginsList()).containsExactlyElementsIn(plugins);
	224	+	}
	225	+
219	226		private void assertRunResponseContainsAllRunRequestParameters(
220	227		RunResponse response, RunRequest request) throws Exception {
221	228		for (MatchedPlugin plugin : request.getPluginsList()) {
		skipped 34 lines
256	263		.addPlugins(MatchedPlugin.newBuilder().addServices(httpService).setPlugin(singlePlugin))
257	264		.build();
258	265		}
259		-	// TODO(b/236740807): Add test case for errors related to RPC calls once wrapper CL is done.
260	266		}
261	267