From 88252782b64809d3d44d7510f2e648c13aa5aa96 Mon Sep 17 00:00:00 2001 From: Arnout Engelen Date: Wed, 11 Mar 2020 09:03:57 +0100 Subject: [PATCH] Remove unused values (#847) --- .../grpc/gen/javadsl/JavaCodeGenerator.scala | 10 +++++-- .../scala/akka/grpc/gen/scaladsl/Method.scala | 14 --------- .../gen/scaladsl/ScalaCodeGenerator.scala | 8 +++-- .../ScalaMarshallersCodeGenerator.scala | 6 +++- .../templates/JavaServer/Handler.scala.txt | 2 +- .../ScalaCommon/Marshallers.scala.txt | 14 ++++----- .../templates/ScalaServer/Handler.scala.txt | 2 +- .../grpc/interop/AkkaGrpcServerScala.scala | 1 - .../interop/AkkaGrpcScalaClientTester.scala | 1 - .../akka/grpc/interop/TestServiceImpl.scala | 1 - .../scaladsl/GrpcExceptionHandlerSpec.scala | 7 ++--- .../scala/akka/grpc/maven/GenerateMojo.scala | 2 +- .../helloworld/JGreeterServiceSpec.scala | 1 - project/Common.scala | 13 +++++++-- project/ReflectiveCodeGen.scala | 3 +- .../847-unused-values.backwards.excludes | 6 ++++ .../scala/akka/grpc/GrpcClientSettings.scala | 20 ++++++------- .../grpc/internal/AbstractGrpcProtocol.scala | 1 - .../internal/AkkaDiscoveryNameResolver.scala | 2 +- .../grpc/internal/AkkaGrpcClientFactory.scala | 1 - .../AkkaNettyGrpcClientGraphStage.scala | 3 -- .../akka/grpc/internal/ChannelUtils.scala | 6 ++-- .../grpc/internal/GrpcEntityHelpers.scala | 12 ++------ .../grpc/internal/GrpcProtocolNative.scala | 6 ++-- .../akka/grpc/internal/GrpcProtocolWeb.scala | 8 ++--- .../grpc/internal/GrpcRequestHelpers.scala | 3 +- .../grpc/internal/GrpcResponseHelpers.scala | 3 -- .../akka/grpc/internal/InternalChannel.scala | 5 +--- .../akka/grpc/internal/NettyClientUtils.scala | 6 ++-- .../grpc/internal/RequestBuilderImpl.scala | 1 - .../akka/grpc/javadsl/GrpcMarshalling.scala | 10 +++---- .../akka/grpc/javadsl/RequestBuilder.scala | 2 +- .../akka/grpc/javadsl/ServiceHandler.scala | 4 --- .../akka/grpc/scaladsl/GrpcMarshalling.scala | 18 ++++++------ .../akka/grpc/scaladsl/RequestBuilder.scala | 5 ++-- .../src/test/scala/akka/grpc/CodecsSpec.scala | 2 +- .../akka/grpc/GrpcClientSettingsSpec.scala | 2 +- .../akka/grpc/internal/ClientStateSpec.scala | 2 -- .../grpc/internal/NettyClientUtilsSpec.scala | 5 ---- .../internal/ServerReflectionImplSpec.scala | 8 ----- .../scaladsl/GrpcExceptionHandlerSpec.scala | 4 +-- .../scala/akka/grpc/sbt/AkkaGrpcPlugin.scala | 29 ------------------- 42 files changed, 96 insertions(+), 163 deletions(-) create mode 100644 runtime/src/main/mima-filters/0.7.3.backwards.excludes/847-unused-values.backwards.excludes diff --git a/codegen/src/main/scala/akka/grpc/gen/javadsl/JavaCodeGenerator.scala b/codegen/src/main/scala/akka/grpc/gen/javadsl/JavaCodeGenerator.scala index a3e75b876..a11866e94 100644 --- a/codegen/src/main/scala/akka/grpc/gen/javadsl/JavaCodeGenerator.scala +++ b/codegen/src/main/scala/akka/grpc/gen/javadsl/JavaCodeGenerator.scala @@ -13,14 +13,20 @@ import templates.JavaCommon.txt.ApiInterface import scala.collection.JavaConverters._ import scala.collection.immutable +import com.github.ghik.silencer.silent + abstract class JavaCodeGenerator extends CodeGenerator { /** Override this to add generated files per service */ def perServiceContent: Set[(Logger, Service) => immutable.Seq[CodeGeneratorResponse.File]] = Set.empty /** Override these to add service-independent generated files */ - def staticContent(logger: Logger): Set[CodeGeneratorResponse.File] = Set.empty - def staticContent(logger: Logger, allServices: Seq[Service]): Set[CodeGeneratorResponse.File] = Set.empty + def staticContent(@silent("never used") logger: Logger): Set[CodeGeneratorResponse.File] = + Set.empty + def staticContent( + @silent("never used") logger: Logger, + @silent("never used") allServices: Seq[Service]): Set[CodeGeneratorResponse.File] = + Set.empty override def run(request: CodeGeneratorRequest, logger: Logger): CodeGeneratorResponse = { val b = CodeGeneratorResponse.newBuilder diff --git a/codegen/src/main/scala/akka/grpc/gen/scaladsl/Method.scala b/codegen/src/main/scala/akka/grpc/gen/scaladsl/Method.scala index 20d40682a..326d71489 100644 --- a/codegen/src/main/scala/akka/grpc/gen/scaladsl/Method.scala +++ b/codegen/src/main/scala/akka/grpc/gen/scaladsl/Method.scala @@ -70,18 +70,4 @@ object Method { import ops._ messageType.scalaType.fullName } - - private def outerClass(t: Descriptor) = - if (t.getFile.toProto.getOptions.getJavaMultipleFiles) "" - else { - val outerClassName = t.getFile.toProto.getOptions.getJavaOuterClassname - if (outerClassName == "") { - protoName(t).head.toUpper + protoName(t).tail + "." - } else { - outerClassName + "." - } - } - - private def protoName(t: Descriptor) = - t.getFile.getName.replaceAll("\\.proto", "").split("/").last } diff --git a/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaCodeGenerator.scala b/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaCodeGenerator.scala index 858e49198..43901f9c4 100644 --- a/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaCodeGenerator.scala +++ b/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaCodeGenerator.scala @@ -12,13 +12,17 @@ import com.google.protobuf.compiler.PluginProtos.{ CodeGeneratorRequest, CodeGen import scalapb.compiler.GeneratorParams import protocbridge.Artifact +import com.github.ghik.silencer.silent + abstract class ScalaCodeGenerator extends CodeGenerator { // Override this to add generated files per service def perServiceContent: Set[(Logger, Service) => immutable.Seq[CodeGeneratorResponse.File]] = Set.empty // Override these to add service-independent generated files - def staticContent(logger: Logger): Set[CodeGeneratorResponse.File] = Set.empty - def staticContent(logger: Logger, allServices: Seq[Service]): Set[CodeGeneratorResponse.File] = Set.empty + def staticContent(@silent("never used") logger: Logger): Set[CodeGeneratorResponse.File] = Set.empty + def staticContent( + @silent("never used") logger: Logger, + @silent("never used") allServices: Seq[Service]): Set[CodeGeneratorResponse.File] = Set.empty override def suggestedDependencies = (scalaBinaryVersion: CodeGenerator.ScalaBinaryVersion) => diff --git a/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaMarshallersCodeGenerator.scala b/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaMarshallersCodeGenerator.scala index 9b6ffd52f..6b32c0d54 100644 --- a/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaMarshallersCodeGenerator.scala +++ b/codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaMarshallersCodeGenerator.scala @@ -10,6 +10,8 @@ import com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse import protocbridge.Artifact import templates.ScalaCommon.txt._ +import com.github.ghik.silencer.silent + /** * Has to be a separate generator rather than a parameter to the existing ones, because * it introduces a suggestedDependency on akka-http. @@ -24,7 +26,9 @@ trait ScalaMarshallersCodeGenerator extends ScalaCodeGenerator { Artifact("com.typesafe.akka", s"akka-http_${scalaBinaryVersion.prefix}", BuildInfo.akkaHttpVersion) +: super .suggestedDependencies(scalaBinaryVersion) - def generateMarshalling(logger: Logger, service: Service): immutable.Seq[CodeGeneratorResponse.File] = { + def generateMarshalling( + @silent("never used") logger: Logger, + service: Service): immutable.Seq[CodeGeneratorResponse.File] = { val b = CodeGeneratorResponse.File.newBuilder() b.setContent(Marshallers(service).body) b.setName(s"${service.packageDir}/${service.name}Marshallers.scala") diff --git a/codegen/src/main/twirl/templates/JavaServer/Handler.scala.txt b/codegen/src/main/twirl/templates/JavaServer/Handler.scala.txt index 13023b1ca..9d7579ee8 100644 --- a/codegen/src/main/twirl/templates/JavaServer/Handler.scala.txt +++ b/codegen/src/main/twirl/templates/JavaServer/Handler.scala.txt @@ -124,7 +124,7 @@ import static @{service.packageName}.@{service.name}.Serializers.*; case "@method.grpcName": response = @{method.unmarshal}(request.entity().getDataBytes(), @method.deserializer.name, mat, reader) .@{if(method.outputStreaming) { "thenApply" } else { "thenCompose" }}(e -> implementation.@{method.name}(e@{if(powerApis) { ", metadata" } else { "" }})) - .thenApply(e -> @{method.marshal}(e, @method.serializer.name, mat, writer, system, eHandler)); + .thenApply(e -> @{method.marshal}(e, @method.serializer.name, writer, system, eHandler)); break; } default: diff --git a/codegen/src/main/twirl/templates/ScalaCommon/Marshallers.scala.txt b/codegen/src/main/twirl/templates/ScalaCommon/Marshallers.scala.txt index 97f39c9c6..e6ede17cc 100644 --- a/codegen/src/main/twirl/templates/ScalaCommon/Marshallers.scala.txt +++ b/codegen/src/main/twirl/templates/ScalaCommon/Marshallers.scala.txt @@ -11,11 +11,9 @@ import scala.concurrent.ExecutionContext import akka.actor.ActorSystem import akka.stream.Materializer -import akka.grpc.Codec import akka.grpc.GrpcProtocol.GrpcProtocolWriter import akka.grpc.ProtobufSerializer import akka.grpc.scaladsl.GrpcMarshalling -import akka.grpc.internal.GrpcProtocolNative import akka.http.scaladsl.marshalling.Marshaller import akka.http.scaladsl.marshalling.ToResponseMarshaller import akka.http.scaladsl.model.HttpRequest @@ -28,14 +26,14 @@ object @{service.name}Marshallers { } implicit def unmarshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer): FromRequestUnmarshaller[T] = - Unmarshaller((ec: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshal(req)(serializer, mat)) + Unmarshaller((_: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshal(req)(serializer, mat)) implicit def toSourceUnmarshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer): FromRequestUnmarshaller[akka.stream.scaladsl.Source[T, akka.NotUsed]] = - Unmarshaller((ec: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshalStream(req)(serializer, mat)) + Unmarshaller((_: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshalStream(req)(serializer, mat)) - implicit def marshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[T] = - Marshaller.opaque((response: T) => GrpcMarshalling.marshal(response)(serializer, mat, writer, system)) + implicit def marshaller[T](implicit serializer: ProtobufSerializer[T], writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[T] = + Marshaller.opaque((response: T) => GrpcMarshalling.marshal(response)(serializer, writer, system)) - implicit def fromSourceMarshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[akka.stream.scaladsl.Source[T, akka.NotUsed]] = - Marshaller.opaque((response: akka.stream.scaladsl.Source[T, akka.NotUsed]) => GrpcMarshalling.marshalStream(response)(serializer, mat, writer, system)) + implicit def fromSourceMarshaller[T](implicit serializer: ProtobufSerializer[T], writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[akka.stream.scaladsl.Source[T, akka.NotUsed]] = + Marshaller.opaque((response: akka.stream.scaladsl.Source[T, akka.NotUsed]) => GrpcMarshalling.marshalStream(response)(serializer, writer, system)) } diff --git a/codegen/src/main/twirl/templates/ScalaServer/Handler.scala.txt b/codegen/src/main/twirl/templates/ScalaServer/Handler.scala.txt index 4f35db1dc..0fced4e86 100644 --- a/codegen/src/main/twirl/templates/ScalaServer/Handler.scala.txt +++ b/codegen/src/main/twirl/templates/ScalaServer/Handler.scala.txt @@ -90,7 +90,7 @@ import akka.stream.Materializer @{if(powerApis) { "val metadata = MetadataBuilder.fromHeaders(request.headers)" } else { "" }} @{method.unmarshal}(request.entity.dataBytes)(@method.deserializer.name, mat, reader) .@{if(method.outputStreaming) { "map" } else { "flatMap" }}(implementation.@{method.name}(_@{if(powerApis) { ", metadata" } else { "" }})) - .map(e => @{method.marshal}(e, eHandler)(@method.serializer.name, mat, writer, system)) + .map(e => @{method.marshal}(e, eHandler)(@method.serializer.name, writer, system)) } case m => scala.concurrent.Future.failed(new NotImplementedError(s"Not implemented: $m")) }) diff --git a/interop-tests/src/main/scala/akka/grpc/interop/AkkaGrpcServerScala.scala b/interop-tests/src/main/scala/akka/grpc/interop/AkkaGrpcServerScala.scala index fd6ccd02f..c0ac84d59 100644 --- a/interop-tests/src/main/scala/akka/grpc/interop/AkkaGrpcServerScala.scala +++ b/interop-tests/src/main/scala/akka/grpc/interop/AkkaGrpcServerScala.scala @@ -31,7 +31,6 @@ case class AkkaGrpcServerScala(serverHandlerFactory: Materializer => ActorSystem override def start() = { implicit val sys = ActorSystem() implicit val mat = ActorMaterializer() - implicit val ec = sys.dispatcher val testService = serverHandlerFactory(mat)(sys) diff --git a/interop-tests/src/test/scala/akka/grpc/interop/AkkaGrpcScalaClientTester.scala b/interop-tests/src/test/scala/akka/grpc/interop/AkkaGrpcScalaClientTester.scala index 0cbe394da..f938bf704 100644 --- a/interop-tests/src/test/scala/akka/grpc/interop/AkkaGrpcScalaClientTester.scala +++ b/interop-tests/src/test/scala/akka/grpc/interop/AkkaGrpcScalaClientTester.scala @@ -20,7 +20,6 @@ import org.junit.Assert._ import scala.concurrent.duration._ import scala.concurrent.{ Await, Future } -import scala.util.Failure import scala.util.control.NoStackTrace /** diff --git a/interop-tests/src/test/scala/akka/grpc/interop/TestServiceImpl.scala b/interop-tests/src/test/scala/akka/grpc/interop/TestServiceImpl.scala index 0b3508770..ead9b246c 100644 --- a/interop-tests/src/test/scala/akka/grpc/interop/TestServiceImpl.scala +++ b/interop-tests/src/test/scala/akka/grpc/interop/TestServiceImpl.scala @@ -12,7 +12,6 @@ import com.google.protobuf.ByteString import io.grpc.Status import io.grpc.testing.integration.empty.Empty -import scala.collection.immutable import scala.concurrent.{ ExecutionContext, Future } // Generated by our plugin diff --git a/interop-tests/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala b/interop-tests/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala index 76216fdaa..c0b25a193 100644 --- a/interop-tests/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala +++ b/interop-tests/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala @@ -8,8 +8,8 @@ import scala.concurrent.Future import akka.actor.ActorSystem -import akka.grpc.{ GrpcServiceException, Identity } -import akka.grpc.internal.{ GrpcEntityHelpers, GrpcProtocolNative, GrpcRequestHelpers } +import akka.grpc.Identity +import akka.grpc.internal.{ GrpcProtocolNative, GrpcRequestHelpers } import akka.grpc.scaladsl.headers.`Status` import akka.http.scaladsl.model.{ HttpEntity, HttpRequest, HttpResponse } import akka.http.scaladsl.model.HttpEntity.{ Chunked, LastChunk } @@ -44,7 +44,7 @@ class GrpcExceptionHandlerSpec .recoverWith(GrpcExceptionHandler.defaultHandler) result.futureValue.entity match { - case Chunked(contentType, chunks) => + case Chunked(_, chunks) => chunks.runWith(Sink.seq).futureValue match { case Seq(LastChunk("", List(`Status`("3")))) => // ok } @@ -130,7 +130,6 @@ class GrpcExceptionHandlerSpec } "return the correct user-supplied status for a streaming call" in { - import akka.http.scaladsl.client.RequestBuilding._ implicit val serializer = example.myapp.helloworld.grpc.helloworld.GreeterService.Serializers.HelloRequestSerializer implicit val writer = GrpcProtocolNative.newWriter(Identity) diff --git a/maven-plugin/src/main/scala/akka/grpc/maven/GenerateMojo.scala b/maven-plugin/src/main/scala/akka/grpc/maven/GenerateMojo.scala index 5add267a3..7a8f16d00 100644 --- a/maven-plugin/src/main/scala/akka/grpc/maven/GenerateMojo.scala +++ b/maven-plugin/src/main/scala/akka/grpc/maven/GenerateMojo.scala @@ -69,7 +69,7 @@ object GenerateMojo { case "scala" => Scala case "java" => Java case unknown => - throw new IllegalArgumentException("[$unknown] is not a supported language, supported are java or scala") + throw new IllegalArgumentException("[" + unknown + "] is not a supported language, supported are java or scala") } /** diff --git a/plugin-tester-java/src/test/scala/example/myapp/helloworld/JGreeterServiceSpec.scala b/plugin-tester-java/src/test/scala/example/myapp/helloworld/JGreeterServiceSpec.scala index 9ce5583f4..f2e7be896 100644 --- a/plugin-tester-java/src/test/scala/example/myapp/helloworld/JGreeterServiceSpec.scala +++ b/plugin-tester-java/src/test/scala/example/myapp/helloworld/JGreeterServiceSpec.scala @@ -8,7 +8,6 @@ import scala.concurrent.Await import org.scalatest.BeforeAndAfterAll import scala.concurrent.duration._ -import scala.language.postfixOps import akka.actor.ActorSystem import akka.grpc.GrpcClientSettings diff --git a/project/Common.scala b/project/Common.scala index d4d9f820d..be00dee1c 100644 --- a/project/Common.scala +++ b/project/Common.scala @@ -30,7 +30,14 @@ object Common extends AutoPlugin { val silencerVersion = "1.6.0" override lazy val projectSettings = Seq( projectInfoVersion := (if (isSnapshot.value) "snapshot" else version.value), - scalacOptions ++= List("-unchecked", "-deprecation", "-language:_", "-Xfatal-warnings", "-encoding", "UTF-8"), + scalacOptions ++= List( + "-unchecked", + "-deprecation", + "-language:_", + "-Xfatal-warnings", + "-Ywarn-unused", + "-encoding", + "UTF-8"), Compile / scalacOptions ++= Seq( // generated code for methods/fields marked 'deprecated' "-P:silencer:globalFilters=Marked as deprecated in proto file", @@ -38,7 +45,9 @@ object Common extends AutoPlugin { "-P:silencer:globalFilters=unbalanced or unclosed heading", // deprecated in 2.13, but used as long as we support 2.12 "-P:silencer:globalFilters=Use `scala.jdk.CollectionConverters` instead", - "-P:silencer:globalFilters=Use LazyList instead of Stream"), + "-P:silencer:globalFilters=Use LazyList instead of Stream", + // ignore imports in templates + "-P:silencer:pathFilters=.*.txt"), javacOptions ++= List("-Xlint:unchecked", "-Xlint:deprecation"), Compile / doc / scalacOptions := scalacOptions.value ++ Seq( "-doc-title", diff --git a/project/ReflectiveCodeGen.scala b/project/ReflectiveCodeGen.scala index 8cf77a284..77b60bbf3 100644 --- a/project/ReflectiveCodeGen.scala +++ b/project/ReflectiveCodeGen.scala @@ -104,13 +104,12 @@ object ReflectiveCodeGen extends AutoPlugin { |val languages: Seq[AkkaGrpc.Language] = Seq($languages) |val sources: Seq[AkkaGrpc.GeneratedSource] = Seq($sources) |val scalaBinaryVersion = ScalaBinaryVersion("$scalaBinaryVersion") - |val generatorSettings: Seq[String] = Seq($generatorSettings1) | |val logger = akka.grpc.gen.StdoutLogger | |(targetPath: java.io.File, settings: Seq[String]) => { | val generators = - | AkkaGrpcPlugin.generatorsFor(sources, languages, generatorSettings, scalaBinaryVersion, logger) ++ + | AkkaGrpcPlugin.generatorsFor(sources, languages, scalaBinaryVersion, logger) ++ | Seq($extraGenerators).map(gen => AkkaGrpcPlugin.toGenerator(gen, scalaBinaryVersion, akka.grpc.gen.StdoutLogger)) | AkkaGrpcPlugin.targetsFor(targetPath, settings, generators) |} diff --git a/runtime/src/main/mima-filters/0.7.3.backwards.excludes/847-unused-values.backwards.excludes b/runtime/src/main/mima-filters/0.7.3.backwards.excludes/847-unused-values.backwards.excludes new file mode 100644 index 000000000..80bbe4e4b --- /dev/null +++ b/runtime/src/main/mima-filters/0.7.3.backwards.excludes/847-unused-values.backwards.excludes @@ -0,0 +1,6 @@ +ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.javadsl.GrpcMarshalling.marshal*") +ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.scaladsl.GrpcMarshalling.marshal*") +ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.internal.ChannelUtils.closeCS") +ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.internal.ChannelUtils.close") +ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.internal.GrpcResponseHelpers.apply") +ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.grpc.internal.GrpcResponseHelpers.apply") diff --git a/runtime/src/main/scala/akka/grpc/GrpcClientSettings.scala b/runtime/src/main/scala/akka/grpc/GrpcClientSettings.scala index 71880e90a..8dede5ef9 100644 --- a/runtime/src/main/scala/akka/grpc/GrpcClientSettings.scala +++ b/runtime/src/main/scala/akka/grpc/GrpcClientSettings.scala @@ -195,18 +195,18 @@ final class GrpcClientSettings private ( val serviceDiscovery: ServiceDiscovery, val defaultPort: Int, val resolveTimeout: FiniteDuration, - val servicePortName: Option[String] = None, - val serviceProtocol: Option[String] = None, + val servicePortName: Option[String], + val serviceProtocol: Option[String], val creationAttempts: Integer, val creationDelay: FiniteDuration, - val connectionAttempts: Option[Int] = None, - val callCredentials: Option[CallCredentials] = None, - val overrideAuthority: Option[String] = None, - val sslContext: Option[SSLContext] = None, - val deadline: Duration = Duration.Undefined, - val userAgent: Option[String] = None, - val useTls: Boolean = true, - val grpcLoadBalancingType: Option[String] = None, + val connectionAttempts: Option[Int], + val callCredentials: Option[CallCredentials], + val overrideAuthority: Option[String], + val sslContext: Option[SSLContext], + val deadline: Duration, + val userAgent: Option[String], + val useTls: Boolean, + val grpcLoadBalancingType: Option[String], val channelBuilderOverrides: NettyChannelBuilder => NettyChannelBuilder = identity) { /** diff --git a/runtime/src/main/scala/akka/grpc/internal/AbstractGrpcProtocol.scala b/runtime/src/main/scala/akka/grpc/internal/AbstractGrpcProtocol.scala index 6cdd434ba..259f6ec87 100644 --- a/runtime/src/main/scala/akka/grpc/internal/AbstractGrpcProtocol.scala +++ b/runtime/src/main/scala/akka/grpc/internal/AbstractGrpcProtocol.scala @@ -84,7 +84,6 @@ object AbstractGrpcProtocol { Flow[Frame].map(encodeFrame)) def reader( - protocol: GrpcProtocol, codec: Codec, decodeFrame: (Int, ByteString) => Frame, flowAdapter: Flow[ByteString, Frame, NotUsed] => Flow[ByteString, Frame, NotUsed] = identity) diff --git a/runtime/src/main/scala/akka/grpc/internal/AkkaDiscoveryNameResolver.scala b/runtime/src/main/scala/akka/grpc/internal/AkkaDiscoveryNameResolver.scala index 763175e8c..f6ba55c60 100644 --- a/runtime/src/main/scala/akka/grpc/internal/AkkaDiscoveryNameResolver.scala +++ b/runtime/src/main/scala/akka/grpc/internal/AkkaDiscoveryNameResolver.scala @@ -4,7 +4,7 @@ package akka.grpc.internal -import java.net.{ InetAddress, InetSocketAddress, SocketAddress, URI, UnknownHostException } +import java.net.{ InetAddress, InetSocketAddress, UnknownHostException } import akka.discovery.ServiceDiscovery.ResolvedTarget import akka.discovery.{ Lookup, ServiceDiscovery } diff --git a/runtime/src/main/scala/akka/grpc/internal/AkkaGrpcClientFactory.scala b/runtime/src/main/scala/akka/grpc/internal/AkkaGrpcClientFactory.scala index 4a8ac3027..eaa5822a0 100644 --- a/runtime/src/main/scala/akka/grpc/internal/AkkaGrpcClientFactory.scala +++ b/runtime/src/main/scala/akka/grpc/internal/AkkaGrpcClientFactory.scala @@ -9,7 +9,6 @@ import scala.reflect.{ classTag, ClassTag } import akka.grpc.GrpcClientSettings import akka.grpc.scaladsl.AkkaGrpcClient import akka.stream.Materializer -import language.reflectiveCalls object AkkaGrpcClientFactory { def create[T <: AkkaGrpcClient: ClassTag]( diff --git a/runtime/src/main/scala/akka/grpc/internal/AkkaNettyGrpcClientGraphStage.scala b/runtime/src/main/scala/akka/grpc/internal/AkkaNettyGrpcClientGraphStage.scala index 8e2a36b8b..63c74b902 100644 --- a/runtime/src/main/scala/akka/grpc/internal/AkkaNettyGrpcClientGraphStage.scala +++ b/runtime/src/main/scala/akka/grpc/internal/AkkaNettyGrpcClientGraphStage.scala @@ -4,8 +4,6 @@ package akka.grpc.internal -import java.util.concurrent.CompletionStage - import akka.annotation.InternalApi import akka.dispatch.ExecutionContexts import akka.grpc.GrpcResponseMetadata @@ -13,7 +11,6 @@ import akka.stream import akka.stream.{ Attributes => _, _ } import akka.stream.stage._ import io.grpc._ -import io.grpc.stub.StreamObserver import scala.concurrent.{ Future, Promise } import scala.compat.java8.FutureConverters._ diff --git a/runtime/src/main/scala/akka/grpc/internal/ChannelUtils.scala b/runtime/src/main/scala/akka/grpc/internal/ChannelUtils.scala index cb4be4437..46f308fb1 100644 --- a/runtime/src/main/scala/akka/grpc/internal/ChannelUtils.scala +++ b/runtime/src/main/scala/akka/grpc/internal/ChannelUtils.scala @@ -12,7 +12,7 @@ import akka.event.LoggingAdapter import io.grpc.{ ConnectivityState, ManagedChannel } import scala.compat.java8.FutureConverters._ -import scala.concurrent.{ ExecutionContext, Future, Promise } +import scala.concurrent.{ Future, Promise } /** * Used to indicate that a gRPC client can not establish a connection @@ -33,7 +33,7 @@ object ChannelUtils { * INTERNAL API */ @InternalApi - def close(internalChannel: InternalChannel)(implicit ec: ExecutionContext): Future[Done] = { + def close(internalChannel: InternalChannel): Future[Done] = { internalChannel.managedChannel.shutdown() internalChannel.done } @@ -42,7 +42,7 @@ object ChannelUtils { * INTERNAL API */ @InternalApi - def closeCS(internalChannel: InternalChannel)(implicit ec: ExecutionContext): CompletionStage[Done] = + def closeCS(internalChannel: InternalChannel): CompletionStage[Done] = close(internalChannel).toJava /** diff --git a/runtime/src/main/scala/akka/grpc/internal/GrpcEntityHelpers.scala b/runtime/src/main/scala/akka/grpc/internal/GrpcEntityHelpers.scala index 60528e04c..cb6a196cb 100644 --- a/runtime/src/main/scala/akka/grpc/internal/GrpcEntityHelpers.scala +++ b/runtime/src/main/scala/akka/grpc/internal/GrpcEntityHelpers.scala @@ -13,7 +13,6 @@ import akka.grpc.scaladsl.{ headers, BytesEntry, Metadata, StringEntry } import akka.http.scaladsl.model.HttpEntity.ChunkStreamPart import akka.http.scaladsl.model.HttpHeader import akka.http.scaladsl.model.headers.RawHeader -import akka.stream.Materializer import akka.stream.scaladsl.Source import io.grpc.Status @@ -25,7 +24,6 @@ object GrpcEntityHelpers { trail: Source[TrailerFrame, NotUsed], eHandler: ActorSystem => PartialFunction[Throwable, Trailers])( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): Source[ChunkStreamPart, NotUsed] = { chunks(e, trail).recover { @@ -38,18 +36,12 @@ object GrpcEntityHelpers { } } - def apply[T](e: T)( - implicit m: ProtobufSerializer[T], - mat: Materializer, - writer: GrpcProtocolWriter, - system: ActorSystem): Source[ChunkStreamPart, NotUsed] = + def apply[T](e: T)(implicit m: ProtobufSerializer[T], writer: GrpcProtocolWriter): Source[ChunkStreamPart, NotUsed] = chunks(Source.single(e), Source.empty) private def chunks[T](e: Source[T, NotUsed], trail: Source[Frame, NotUsed])( implicit m: ProtobufSerializer[T], - mat: Materializer, - writer: GrpcProtocolWriter, - system: ActorSystem): Source[ChunkStreamPart, NotUsed] = + writer: GrpcProtocolWriter): Source[ChunkStreamPart, NotUsed] = e.map { msg => DataFrame(m.serialize(msg)) }.concat(trail).via(writer.frameEncoder) def trailer(status: Status): TrailerFrame = diff --git a/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolNative.scala b/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolNative.scala index 6814b1cbe..9086f811a 100644 --- a/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolNative.scala +++ b/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolNative.scala @@ -9,6 +9,8 @@ import akka.grpc.GrpcProtocol._ import akka.http.scaladsl.model.HttpEntity.{ Chunk, ChunkStreamPart, LastChunk } import akka.util.ByteString +import com.github.ghik.silencer.silent + /** * Implementation of the gRPC (`application/grpc+proto`) protocol: * @@ -23,10 +25,10 @@ object GrpcProtocolNative extends AbstractGrpcProtocol("grpc") { AbstractGrpcProtocol.writer(this, codec, encodeFrame(codec, _)) override protected def reader(codec: Codec): GrpcProtocolReader = - AbstractGrpcProtocol.reader(this, codec, decodeFrame) + AbstractGrpcProtocol.reader(codec, decodeFrame) @inline - private def decodeFrame(frameType: Int, data: ByteString) = DataFrame(data) + private def decodeFrame(@silent("never used") frameType: Int, data: ByteString) = DataFrame(data) @inline private def encodeFrame(codec: Codec, frame: Frame): ChunkStreamPart = { diff --git a/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolWeb.scala b/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolWeb.scala index 344180d3f..f0baaff41 100644 --- a/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolWeb.scala +++ b/runtime/src/main/scala/akka/grpc/internal/GrpcProtocolWeb.scala @@ -22,11 +22,7 @@ abstract class GrpcProtocolWebBase(subType: String) extends AbstractGrpcProtocol AbstractGrpcProtocol.writer(this, codec, frame => encodeFrame(codec, frame)) override protected def reader(codec: Codec): GrpcProtocolReader = - AbstractGrpcProtocol.reader( - this, - codec, - decodeFrame, - flow => Flow[ByteString].map(frame => preDecode(frame)).via(flow)) + AbstractGrpcProtocol.reader(codec, decodeFrame, flow => Flow[ByteString].map(frame => preDecode(frame)).via(flow)) @inline private def encodeFrame(codec: Codec, frame: Frame): ChunkStreamPart = { @@ -44,7 +40,7 @@ abstract class GrpcProtocolWebBase(subType: String) extends AbstractGrpcProtocol (frameHeader & 80) match { case 0 => DataFrame(data) case 1 => TrailerFrame(decodeTrailer(data)) - case f => throw new StatusException(Status.INTERNAL.withDescription("Unknown frame type $f")) + case f => throw new StatusException(Status.INTERNAL.withDescription(s"Unknown frame type [$f]")) } } diff --git a/runtime/src/main/scala/akka/grpc/internal/GrpcRequestHelpers.scala b/runtime/src/main/scala/akka/grpc/internal/GrpcRequestHelpers.scala index 34da0ba20..6f3d0ac8b 100644 --- a/runtime/src/main/scala/akka/grpc/internal/GrpcRequestHelpers.scala +++ b/runtime/src/main/scala/akka/grpc/internal/GrpcRequestHelpers.scala @@ -3,11 +3,11 @@ */ package akka.grpc.internal + import akka.actor.ActorSystem import akka.grpc.{ Codecs, ProtobufSerializer, Trailers } import akka.grpc.GrpcProtocol.GrpcProtocolWriter import akka.http.scaladsl.model.HttpEntity.ChunkStreamPart -import akka.stream.Materializer import akka.stream.scaladsl.Source import akka.NotUsed import akka.annotation.InternalApi @@ -25,7 +25,6 @@ object GrpcRequestHelpers { e: Source[T, NotUsed], eHandler: ActorSystem => PartialFunction[Throwable, Trailers] = GrpcExceptionHandler.defaultMapper)( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpRequest = request(uri, GrpcEntityHelpers(e, Source.single(GrpcEntityHelpers.trailer(Status.OK)), eHandler)) diff --git a/runtime/src/main/scala/akka/grpc/internal/GrpcResponseHelpers.scala b/runtime/src/main/scala/akka/grpc/internal/GrpcResponseHelpers.scala index 3c70ff454..15823fa35 100644 --- a/runtime/src/main/scala/akka/grpc/internal/GrpcResponseHelpers.scala +++ b/runtime/src/main/scala/akka/grpc/internal/GrpcResponseHelpers.scala @@ -28,14 +28,12 @@ import scala.concurrent.{ ExecutionContext, Future } object GrpcResponseHelpers { def apply[T](e: Source[T, NotUsed])( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpResponse = GrpcResponseHelpers(e, Source.single(GrpcEntityHelpers.trailer(Status.OK))) def apply[T](e: Source[T, NotUsed], eHandler: ActorSystem => PartialFunction[Throwable, Trailers])( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpResponse = GrpcResponseHelpers(e, Source.single(GrpcEntityHelpers.trailer(Status.OK)), eHandler) @@ -67,7 +65,6 @@ object GrpcResponseHelpers { trail: Source[TrailerFrame, NotUsed], eHandler: ActorSystem => PartialFunction[Throwable, Trailers] = GrpcExceptionHandler.defaultMapper)( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpResponse = { response(GrpcEntityHelpers(e, trail, eHandler)) diff --git a/runtime/src/main/scala/akka/grpc/internal/InternalChannel.scala b/runtime/src/main/scala/akka/grpc/internal/InternalChannel.scala index 382fad135..07573b33c 100644 --- a/runtime/src/main/scala/akka/grpc/internal/InternalChannel.scala +++ b/runtime/src/main/scala/akka/grpc/internal/InternalChannel.scala @@ -4,10 +4,7 @@ package akka.grpc.internal -import java.util.concurrent.CompletionStage - -import scala.compat.java8.FutureConverters._ -import scala.concurrent.{ ExecutionContext, Future, Promise } +import scala.concurrent.Future import akka.Done import akka.annotation.InternalApi diff --git a/runtime/src/main/scala/akka/grpc/internal/NettyClientUtils.scala b/runtime/src/main/scala/akka/grpc/internal/NettyClientUtils.scala index f3734e4a4..98ec08dae 100644 --- a/runtime/src/main/scala/akka/grpc/internal/NettyClientUtils.scala +++ b/runtime/src/main/scala/akka/grpc/internal/NettyClientUtils.scala @@ -5,21 +5,19 @@ package akka.grpc.internal import java.lang.reflect.Field -import java.util.concurrent.{ ThreadLocalRandom, TimeUnit } +import java.util.concurrent.TimeUnit import akka.Done import akka.annotation.InternalApi -import akka.discovery.Lookup import akka.event.LoggingAdapter import akka.grpc.GrpcClientSettings import io.grpc.CallOptions -import io.grpc.internal.DnsNameResolverProvider import io.grpc.netty.shaded.io.grpc.netty.{ GrpcSslContexts, NegotiationType, NettyChannelBuilder } import io.grpc.netty.shaded.io.netty.handler.ssl._ import javax.net.ssl.SSLContext import scala.concurrent.duration.FiniteDuration -import scala.concurrent.{ ExecutionContext, Future, Promise } +import scala.concurrent.{ ExecutionContext, Promise } /** * Used to indicate that the service discovery returned no target. diff --git a/runtime/src/main/scala/akka/grpc/internal/RequestBuilderImpl.scala b/runtime/src/main/scala/akka/grpc/internal/RequestBuilderImpl.scala index 25d538cce..18dc495e9 100644 --- a/runtime/src/main/scala/akka/grpc/internal/RequestBuilderImpl.scala +++ b/runtime/src/main/scala/akka/grpc/internal/RequestBuilderImpl.scala @@ -5,7 +5,6 @@ package akka.grpc.internal import java.util.concurrent.CompletionStage -import java.util.concurrent.TimeUnit import akka.NotUsed import akka.annotation.InternalApi diff --git a/runtime/src/main/scala/akka/grpc/javadsl/GrpcMarshalling.scala b/runtime/src/main/scala/akka/grpc/javadsl/GrpcMarshalling.scala index 2329ced18..49522dbad 100644 --- a/runtime/src/main/scala/akka/grpc/javadsl/GrpcMarshalling.scala +++ b/runtime/src/main/scala/akka/grpc/javadsl/GrpcMarshalling.scala @@ -18,6 +18,8 @@ import akka.stream.Materializer import akka.stream.javadsl.{ Sink, Source } import akka.util.ByteString +import com.github.ghik.silencer.silent + object GrpcMarshalling { def negotiated[T]( @@ -44,7 +46,7 @@ object GrpcMarshalling { def unmarshalStream[T]( data: Source[ByteString, AnyRef], u: ProtobufSerializer[T], - mat: Materializer, + @silent("never used") mat: Materializer, reader: GrpcProtocolReader): CompletionStage[Source[T, NotUsed]] = { CompletableFuture.completedFuture[Source[T, NotUsed]]( data @@ -60,22 +62,20 @@ object GrpcMarshalling { def marshal[T]( e: T, m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem, eHandler: Function[ActorSystem, Function[Throwable, Trailers]] = GrpcExceptionHandler.defaultMapper) : HttpResponse = - marshalStream(Source.single(e), m, mat, writer, system, eHandler) + marshalStream(Source.single(e), m, writer, system, eHandler) def marshalStream[T]( e: Source[T, NotUsed], m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem, eHandler: Function[ActorSystem, Function[Throwable, Trailers]] = GrpcExceptionHandler.defaultMapper) : HttpResponse = - GrpcResponseHelpers(e.asScala, scalaAnonymousPartialFunction(eHandler))(m, mat, writer, system) + GrpcResponseHelpers(e.asScala, scalaAnonymousPartialFunction(eHandler))(m, writer, system) private def failure[R](error: Throwable): CompletableFuture[R] = { val future: CompletableFuture[R] = new CompletableFuture() diff --git a/runtime/src/main/scala/akka/grpc/javadsl/RequestBuilder.scala b/runtime/src/main/scala/akka/grpc/javadsl/RequestBuilder.scala index d9d342bec..87058d2d9 100644 --- a/runtime/src/main/scala/akka/grpc/javadsl/RequestBuilder.scala +++ b/runtime/src/main/scala/akka/grpc/javadsl/RequestBuilder.scala @@ -8,7 +8,7 @@ import java.util.concurrent.CompletionStage import akka.NotUsed import akka.annotation.DoNotInherit -import akka.grpc.{ GrpcClientSettings, GrpcResponseMetadata, GrpcSingleResponse } +import akka.grpc.{ GrpcResponseMetadata, GrpcSingleResponse } import akka.stream.javadsl.Source import akka.util.ByteString diff --git a/runtime/src/main/scala/akka/grpc/javadsl/ServiceHandler.scala b/runtime/src/main/scala/akka/grpc/javadsl/ServiceHandler.scala index d59d40987..25926b508 100644 --- a/runtime/src/main/scala/akka/grpc/javadsl/ServiceHandler.scala +++ b/runtime/src/main/scala/akka/grpc/javadsl/ServiceHandler.scala @@ -8,7 +8,6 @@ import java.util.concurrent.{ CompletableFuture, CompletionStage } import akka.grpc.scaladsl.{ ServiceHandler => sServiceHandler } import akka.http.javadsl.model.{ HttpRequest, HttpResponse, StatusCodes } -import akka.http.scaladsl.unmarshalling.Unmarshaller // using japi because bindAndHandleAsync expects that import akka.japi.{ Function => JFunction } @@ -22,9 +21,6 @@ object ServiceHandler { private[javadsl] val unsupportedMediaType: CompletionStage[HttpResponse] = CompletableFuture.completedFuture(HttpResponse.create().withStatus(StatusCodes.UNSUPPORTED_MEDIA_TYPE)) - private implicit val idUnmarshaller: Unmarshaller[HttpRequest, HttpRequest] = - Unmarshaller.identityUnmarshaller[HttpRequest] - /** * This is an alias for handler. */ diff --git a/runtime/src/main/scala/akka/grpc/scaladsl/GrpcMarshalling.scala b/runtime/src/main/scala/akka/grpc/scaladsl/GrpcMarshalling.scala index e8685517e..d96663e59 100644 --- a/runtime/src/main/scala/akka/grpc/scaladsl/GrpcMarshalling.scala +++ b/runtime/src/main/scala/akka/grpc/scaladsl/GrpcMarshalling.scala @@ -4,6 +4,10 @@ package akka.grpc.scaladsl +import io.grpc.Status + +import scala.concurrent.Future + import akka.NotUsed import akka.actor.ActorSystem import akka.annotation.InternalApi @@ -14,9 +18,8 @@ import akka.http.scaladsl.model.{ HttpRequest, HttpResponse, Uri } import akka.stream.Materializer import akka.stream.scaladsl.{ Sink, Source } import akka.util.ByteString -import io.grpc.Status -import scala.concurrent.Future +import com.github.ghik.silencer.silent object GrpcMarshalling { def unmarshal[T](req: HttpRequest)(implicit u: ProtobufSerializer[T], mat: Materializer): Future[T] = { @@ -26,8 +29,9 @@ object GrpcMarshalling { }).getOrElse(throw new GrpcServiceException(Status.UNIMPLEMENTED)) } - def unmarshalStream[T]( - req: HttpRequest)(implicit u: ProtobufSerializer[T], mat: Materializer): Future[Source[T, NotUsed]] = { + def unmarshalStream[T](req: HttpRequest)( + implicit u: ProtobufSerializer[T], + @silent("never used") mat: Materializer): Future[Source[T, NotUsed]] = { negotiated(req, (r, _) => { implicit val reader: GrpcProtocolReader = r unmarshalStream(req.entity.dataBytes) @@ -53,7 +57,7 @@ object GrpcMarshalling { def unmarshalStream[T](data: Source[ByteString, Any])( implicit u: ProtobufSerializer[T], - mat: Materializer, + @silent("never used") mat: Materializer, reader: GrpcProtocolReader): Future[Source[T, NotUsed]] = { Future.successful( data @@ -69,7 +73,6 @@ object GrpcMarshalling { e: T = Identity, eHandler: ActorSystem => PartialFunction[Throwable, Trailers] = GrpcExceptionHandler.defaultMapper)( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpResponse = marshalStream(Source.single(e), eHandler) @@ -78,7 +81,6 @@ object GrpcMarshalling { e: Source[T, NotUsed], eHandler: ActorSystem => PartialFunction[Throwable, Trailers] = GrpcExceptionHandler.defaultMapper)( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpResponse = { GrpcResponseHelpers(e, eHandler) @@ -90,7 +92,6 @@ object GrpcMarshalling { e: T, eHandler: ActorSystem => PartialFunction[Throwable, Trailers] = GrpcExceptionHandler.defaultMapper)( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpRequest = marshalStreamRequest(uri, Source.single(e), eHandler) @@ -101,7 +102,6 @@ object GrpcMarshalling { e: Source[T, NotUsed], eHandler: ActorSystem => PartialFunction[Throwable, Trailers] = GrpcExceptionHandler.defaultMapper)( implicit m: ProtobufSerializer[T], - mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): HttpRequest = GrpcRequestHelpers(uri, e, eHandler) diff --git a/runtime/src/main/scala/akka/grpc/scaladsl/RequestBuilder.scala b/runtime/src/main/scala/akka/grpc/scaladsl/RequestBuilder.scala index c1531f942..1d0b0a9ad 100644 --- a/runtime/src/main/scala/akka/grpc/scaladsl/RequestBuilder.scala +++ b/runtime/src/main/scala/akka/grpc/scaladsl/RequestBuilder.scala @@ -6,12 +6,11 @@ package akka.grpc.scaladsl import akka.NotUsed import akka.annotation.DoNotInherit -import akka.grpc.{ GrpcClientSettings, GrpcResponseMetadata, GrpcSingleResponse } +import akka.grpc.{ GrpcResponseMetadata, GrpcSingleResponse } import akka.stream.scaladsl.Source -import akka.util.{ ByteString, JavaDurationConverters } +import akka.util.ByteString import scala.concurrent.Future -import scala.concurrent.duration.FiniteDuration /** * Request builder for requests providing per call specific metadata capabilities in diff --git a/runtime/src/test/scala/akka/grpc/CodecsSpec.scala b/runtime/src/test/scala/akka/grpc/CodecsSpec.scala index d71b07ceb..1b71799f9 100644 --- a/runtime/src/test/scala/akka/grpc/CodecsSpec.scala +++ b/runtime/src/test/scala/akka/grpc/CodecsSpec.scala @@ -8,7 +8,7 @@ import akka.http.scaladsl.model.HttpRequest import io.grpc.Status import org.scalatest.matchers.should.Matchers import org.scalatest.wordspec.AnyWordSpec -import org.scalatest.{ OptionValues, TryValues } +import org.scalatest.TryValues import scala.collection.immutable diff --git a/runtime/src/test/scala/akka/grpc/GrpcClientSettingsSpec.scala b/runtime/src/test/scala/akka/grpc/GrpcClientSettingsSpec.scala index 199b0d9bf..a97c5b805 100644 --- a/runtime/src/test/scala/akka/grpc/GrpcClientSettingsSpec.scala +++ b/runtime/src/test/scala/akka/grpc/GrpcClientSettingsSpec.scala @@ -180,7 +180,7 @@ class GrpcClientSettingsSpec extends AnyWordSpec with Matchers with ScalaFutures } "fail fast when no service discovery is configured on the actor system" in { intercept[IllegalArgumentException] { - val settings = GrpcClientSettings.usingServiceDiscovery("a-downstream-service") + GrpcClientSettings.usingServiceDiscovery("a-downstream-service") } } diff --git a/runtime/src/test/scala/akka/grpc/internal/ClientStateSpec.scala b/runtime/src/test/scala/akka/grpc/internal/ClientStateSpec.scala index 29a7d5578..aac67b56b 100644 --- a/runtime/src/test/scala/akka/grpc/internal/ClientStateSpec.scala +++ b/runtime/src/test/scala/akka/grpc/internal/ClientStateSpec.scala @@ -4,8 +4,6 @@ package akka.grpc.internal -import java.util.concurrent.TimeoutException - import scala.concurrent.duration._ import scala.concurrent.{ Await, Future, Promise } diff --git a/runtime/src/test/scala/akka/grpc/internal/NettyClientUtilsSpec.scala b/runtime/src/test/scala/akka/grpc/internal/NettyClientUtilsSpec.scala index 20120d872..9f55c8e45 100644 --- a/runtime/src/test/scala/akka/grpc/internal/NettyClientUtilsSpec.scala +++ b/runtime/src/test/scala/akka/grpc/internal/NettyClientUtilsSpec.scala @@ -6,9 +6,6 @@ package akka.grpc.internal import com.typesafe.config.ConfigFactory import akka.actor.ActorSystem -import akka.event.Logging -import akka.pattern.AskTimeoutException -import akka.grpc.GrpcClientSettings import org.scalatest._ import org.scalatest.concurrent._ import org.scalatest.matchers.should.Matchers @@ -24,8 +21,6 @@ class NettyClientUtilsSpec extends AnyWordSpec with Matchers with ScalaFutures w """).withFallback(ConfigFactory.load())) "The Netty client-utilities" should { - implicit val ec = system.dispatcher - // The channel can now retry service discovery as needed itself, // I guess we should test that instead? // "fail to create a channel when service discovery times out" in { diff --git a/runtime/src/test/scala/akka/grpc/internal/ServerReflectionImplSpec.scala b/runtime/src/test/scala/akka/grpc/internal/ServerReflectionImplSpec.scala index d8d64fcb8..ab35070e6 100644 --- a/runtime/src/test/scala/akka/grpc/internal/ServerReflectionImplSpec.scala +++ b/runtime/src/test/scala/akka/grpc/internal/ServerReflectionImplSpec.scala @@ -4,14 +4,6 @@ package akka.grpc.internal -import java.util.concurrent.TimeUnit - -import io.grpc._ - -import scala.concurrent.Promise - -import akka.Done - import grpc.reflection.v1alpha.reflection.ServerReflection import org.scalatest.concurrent.ScalaFutures diff --git a/runtime/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala b/runtime/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala index 2a9ef99ee..6f6e8c70b 100644 --- a/runtime/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala +++ b/runtime/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala @@ -34,7 +34,7 @@ class GrpcExceptionHandlerSpec extends AnyWordSpec with Matchers with ScalaFutur case grpcException: GrpcServiceException => grpcException.status case _: NotImplementedError => Status.UNIMPLEMENTED case _: UnsupportedOperationException => Status.UNIMPLEMENTED - case other => Status.INTERNAL + case _ => Status.INTERNAL } val otherTypes: Seq[Throwable] = Seq( @@ -72,7 +72,7 @@ class GrpcExceptionHandlerSpec extends AnyWordSpec with Matchers with ScalaFutur def getChunks(resp: HttpResponse): Seq[ChunkStreamPart] = (resp.entity match { - case Chunked(contentType, chunks) => + case Chunked(_, chunks) => chunks.runFold(Seq.empty[ChunkStreamPart]) { case (seq, chunk) => seq :+ chunk } case _ => Future.successful(Seq.empty[ChunkStreamPart]) }).futureValue diff --git a/sbt-plugin/src/main/scala/akka/grpc/sbt/AkkaGrpcPlugin.scala b/sbt-plugin/src/main/scala/akka/grpc/sbt/AkkaGrpcPlugin.scala index 906cebcbf..62423b4b4 100644 --- a/sbt-plugin/src/main/scala/akka/grpc/sbt/AkkaGrpcPlugin.scala +++ b/sbt-plugin/src/main/scala/akka/grpc/sbt/AkkaGrpcPlugin.scala @@ -4,8 +4,6 @@ package akka.grpc.sbt -import java.io.{ ByteArrayOutputStream, PrintStream } - import akka.grpc.gen.CodeGenerator.ScalaBinaryVersion import akka.grpc.gen.scaladsl.{ ScalaClientCodeGenerator, ScalaServerCodeGenerator, ScalaTraitCodeGenerator } import akka.grpc.gen.javadsl.{ JavaClientCodeGenerator, JavaInterfaceCodeGenerator, JavaServerCodeGenerator } @@ -16,7 +14,6 @@ import sbt.{ GlobFilter, _ } import sbtprotoc.ProtocPlugin import scalapb.ScalaPbCodeGenerator -import scala.util.Try import language.implicitConversions object AkkaGrpcPlugin extends AutoPlugin { @@ -108,7 +105,6 @@ object AkkaGrpcPlugin extends AutoPlugin { generatorsFor( akkaGrpcGeneratedSources.value, akkaGrpcGeneratedLanguages.value, - akkaGrpcCodeGeneratorSettings.value, ScalaBinaryVersion(scalaBinaryVersion.value), generatorLogger) ++ akkaGrpcExtraGenerators.value.map(g => toGenerator(g, ScalaBinaryVersion(scalaBinaryVersion.value), generatorLogger)) @@ -161,7 +157,6 @@ object AkkaGrpcPlugin extends AutoPlugin { def generatorsFor( stubs: Seq[AkkaGrpc.GeneratedSource], languages: Seq[AkkaGrpc.Language], - options: Seq[String], scalaBinaryVersion: ScalaBinaryVersion, logger: GenLogger): Seq[protocbridge.Generator] = { import AkkaGrpc._ @@ -215,30 +210,6 @@ object AkkaGrpcPlugin extends AutoPlugin { override def toString = s"ProtocBridgeSbtPluginCodeGenerator(${impl.name}: $impl)" } - /** - * Redirect stdout and stderr to buffers while running the given block, then reinstall original - * stdin and out and return the logged output - */ - private def captureStdOutAnderr[T](block: => T): (String, String, T) = { - val errBao = new ByteArrayOutputStream() - val errPrinter = new PrintStream(errBao, true, "UTF-8") - val outBao = new ByteArrayOutputStream() - val outPrinter = new PrintStream(outBao, true, "UTF-8") - val originalOut = System.out - val originalErr = System.err - System.setOut(outPrinter) - System.setErr(errPrinter) - val t = - try { - block - } finally { - System.setOut(originalOut) - System.setErr(originalErr) - } - - (outBao.toString("UTF-8"), errBao.toString("UTF-8"), t) - } - private def ancestorConfigsFilter(config: Configuration) = { def ancestors(confs: Vector[Configuration]): Vector[Configuration] = confs ++ confs.flatMap(conf => ancestors(conf.extendsConfigs))