Running jacoco:cover from the Play console using jacoco4sbt (2.1.4) results in many tests failing and messages like:
[debug] Running
TaskDef(com.ourCompany.ourProject.identity.LoginControllerSpec,
org.scalatest.tools.Framework$$anon$1#5b98f69a, false,
[SuiteSelector])
java.lang.NoClassDefFoundError: Could not initialize class com.sun.xml.internal.ws.api.BindingID
at com.sun.xml.internal.ws.wsdl.parser.RuntimeWSDLParser.parseBinding(RuntimeWSDLParser.java:445)
at com.sun.xml.internal.ws.wsdl.parser.RuntimeWSDLParser.parseWSDL(RuntimeWSDLParser.java:342)
at com.sun.xml.internal.ws.wsdl.parser.RuntimeWSDLParser.parse(RuntimeWSDLParser.java:157)
at com.sun.xml.internal.ws.wsdl.parser.RuntimeWSDLParser.parse(RuntimeWSDLParser.java:120)
at com.sun.xml.internal.ws.client.WSServiceDelegate.parseWSDL(WSServiceDelegate.java:257)
at com.sun.xml.internal.ws.client.WSServiceDelegate.(WSServiceDelegate.java:220)
at com.sun.xml.internal.ws.client.WSServiceDelegate.(WSServiceDelegate.java:168)
at com.sun.xml.internal.ws.spi.ProviderImpl.createServiceDelegate(ProviderImpl.java:96)
at javax.xml.ws.Service.(Service.java:77)
at com.bsl.Services.(Services.java:46)
at com.ourCompany.ourProject.identity.UserRepositoryComponent$OdsUserRepository.(UserRepositoryComponent.scala:92)
at com.ourCompany.ourProject.identity.ComponentRegistry$class.$init$(ComponentRegistry.scala:7)
at com.ourCompany.ourProject.identity.LoginControllerSpec$TestLoginController$.(LoginControllerSpec.scala:20)
at com.ourCompany.ourProject.identity.LoginControllerSpec.TestLoginController$lzycompute(LoginControllerSpec.scala:20)
at com.ourCompany.ourProject.identity.LoginControllerSpec.TestLoginController(LoginControllerSpec.scala:20)
at com.ourCompany.ourProject.identity.LoginControllerSpec$$anonfun$1.apply$mcV$sp(LoginControllerSpec.scala:32)
at com.ourCompany.ourProject.identity.LoginControllerSpec$$anonfun$1.apply(LoginControllerSpec.scala:32)
at com.ourCompany.ourProject.identity.LoginControllerSpec$$anonfun$1.apply(LoginControllerSpec.scala:32)
at org.scalatest.Transformer$$anonfun$apply$1.apply(Transformer.scala:22)
at org.scalatest.Transformer$$anonfun$apply$1.apply(Transformer.scala:22)
at org.scalatest.OutcomeOf$class.outcomeOf(OutcomeOf.scala:85)
at org.scalatest.OutcomeOf$.outcomeOf(OutcomeOf.scala:104)
at org.scalatest.Transformer.apply(Transformer.scala:22)
at org.scalatest.Transformer.apply(Transformer.scala:20)
at org.scalatest.FlatSpecLike$$anon$1.apply(FlatSpecLike.scala:1636)
at org.scalatest.Suite$class.withFixture(Suite.scala:1121)
at org.scalatest.FlatSpec.withFixture(FlatSpec.scala:1683)
at org.scalatest.FlatSpecLike$class.invokeWithFixture$1(FlatSpecLike.scala:1633)
at org.scalatest.FlatSpecLike$$anonfun$runTest$1.apply(FlatSpecLike.scala:1645)
at org.scalatest.FlatSpecLike$$anonfun$runTest$1.apply(FlatSpecLike.scala:1645)
at org.scalatest.SuperEngine.runTestImpl(Engine.scala:306)
at org.scalatest.FlatSpecLike$class.runTest(FlatSpecLike.scala:1645)
at org.scalatest.FlatSpec.runTest(FlatSpec.scala:1683)
at org.scalatest.FlatSpecLike$$anonfun$runTests$1.apply(FlatSpecLike.scala:1703)
at org.scalatest.FlatSpecLike$$anonfun$runTests$1.apply(FlatSpecLike.scala:1703)
at org.scalatest.SuperEngine$$anonfun$traverseSubNodes$1$1.apply(Engine.scala:413)
at org.scalatest.SuperEngine$$anonfun$traverseSubNodes$1$1.apply(Engine.scala:401)
at scala.collection.immutable.List.foreach(List.scala:318)
at org.scalatest.SuperEngine.traverseSubNodes$1(Engine.scala:401)
at org.scalatest.SuperEngine.org$scalatest$SuperEngine$$runTestsInBranch(Engine.scala:390)
at org.scalatest.SuperEngine$$anonfun$traverseSubNodes$1$1.apply(Engine.scala:427)
at org.scalatest.SuperEngine$$anonfun$traverseSubNodes$1$1.apply(Engine.scala:401)
at scala.collection.immutable.List.foreach(List.scala:318)
at org.scalatest.SuperEngine.traverseSubNodes$1(Engine.scala:401)
at org.scalatest.SuperEngine.org$scalatest$SuperEngine$$runTestsInBranch(Engine.scala:396)
at org.scalatest.SuperEngine.runTestsImpl(Engine.scala:483)
at org.scalatest.FlatSpecLike$class.runTests(FlatSpecLike.scala:1703)
at org.scalatest.FlatSpec.runTests(FlatSpec.scala:1683)
at org.scalatest.Suite$class.run(Suite.scala:1423)
at org.scalatest.FlatSpec.org$scalatest$FlatSpecLike$$super$run(FlatSpec.scala:1683)
at org.scalatest.FlatSpecLike$$anonfun$run$1.apply(FlatSpecLike.scala:1749)
at org.scalatest.FlatSpecLike$$anonfun$run$1.apply(FlatSpecLike.scala:1749)
at org.scalatest.SuperEngine.runImpl(Engine.scala:545)
at org.scalatest.FlatSpecLike$class.run(FlatSpecLike.scala:1749)
at com.ourCompany.ourProject.identity.LoginControllerSpec.org$scalatest$BeforeAndAfterAll$$super$run(LoginControllerSpec.scala:11)
at org.scalatest.BeforeAndAfterAll$class.liftedTree1$1(BeforeAndAfterAll.scala:257)
at org.scalatest.BeforeAndAfterAll$class.run(BeforeAndAfterAll.scala:256)
at com.ourCompany.ourProject.identity.LoginControllerSpec.run(LoginControllerSpec.scala:11)
at org.scalatest.tools.Framework.org$scalatest$tools$Framework$$runSuite(Framework.scala:444)
at org.scalatest.tools.Framework$ScalaTestTask.execute(Framework.scala:651)
at sbt.TestRunner.runTest$1(TestFramework.scala:84)
at sbt.TestRunner.run(TestFramework.scala:94)
at sbt.TestFramework$$anon$2$$anonfun$$init$$1$$anonfun$apply$8.apply(TestFramework.scala:224)
at sbt.TestFramework$$anon$2$$anonfun$$init$$1$$anonfun$apply$8.apply(TestFramework.scala:224)
at sbt.TestFramework$.sbt$TestFramework$$withContextLoader(TestFramework.scala:212)
at sbt.TestFramework$$anon$2$$anonfun$$init$$1.apply(TestFramework.scala:224)
at sbt.TestFramework$$anon$2$$anonfun$$init$$1.apply(TestFramework.scala:224)
at sbt.TestFunction.apply(TestFramework.scala:229)
at sbt.Tests$.sbt$Tests$$processRunnable$1(Tests.scala:211)
at sbt.Tests$$anonfun$makeSerial$1.apply(Tests.scala:217)
at sbt.Tests$$anonfun$makeSerial$1.apply(Tests.scala:217)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$4.work(System.scala:64)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
at sbt.Execute.work(Execute.scala:244)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)
at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.java:744)
[error] Could not run test com.ourCompany.ourProject.identity.LoginControllerSpec:
java.lang.NoClassDefFoundError: Could not initialize class
com.sun.xml.internal.ws.api.BindingID
LoginControlerSpec
package com.ourCompany.ourProject.identity
import org.scalatest.{ Matchers, BeforeAndAfterAll, FlatSpec }
import play.api.test.{ FakeApplication, FakeRequest }
import com.ourCompany.ourProject.tags.UnitTest
import play.api.Play
import org.specs2.mock.Mockito
import play.api.test.Helpers._
#UnitTest
class LoginControllerSpec extends FlatSpec with BeforeAndAfterAll with Mockito with Matchers {
override def beforeAll() {
Play.start(FakeApplication())
}
override def afterAll() {
Play.stop()
}
object TestLoginController extends LoginController with Secured with ComponentRegistryMock
val Home = "/"
val username = "XXX#ourCompanyprofessional.com"
val password = "XXX1"
val isRememberMe = false
val expirationPolicy = SessionExpirationPolicy
val odsUser = OdsUser(Identity(username, ""), Some(username))
behavior of "LoginController"
it should "send 200 for renderLoginForm with not authenticated user" in {
status(TestLoginController.renderLoginForm(FakeRequest())) should be(OK)
}
it should "send 303 for renderLoginForm with authenticated user" in {
val cookie = TestLoginController.authenticatorService.create(odsUser.identity, expirationPolicy) match {
case Right(a: Authenticator) => a.toCookie
case _ => fail()
}
TestLoginController.userRepository.find(odsUser.identity.userId) returns Some(odsUser)
val result = TestLoginController.renderLoginForm(FakeRequest().withCookies(cookie))
redirectLocation(result) should be(Some(Home))
status(result) should be(SEE_OTHER)
}
it should "send 303 for login with valid credentials" in {
val fakeRequest = FakeRequest().withFormUrlEncodedBody(
UsernameField -> username, PasswordField -> password, RememberMeField -> isRememberMe.toString)
TestLoginController.userRepository.login(username, password) returns Right(odsUser)
val result = TestLoginController.login(fakeRequest)
cookies(result).get(Authenticator.cookieName) match {
case Some(c) => assert(c.name == Authenticator.cookieName && !c.value.isEmpty)
case _ => fail()
}
redirectLocation(result) should be(Some(Home))
status(result) should be(SEE_OTHER)
}
it should "send 400 for login with invalid credentials" in {
val fakeRequest = FakeRequest().withFormUrlEncodedBody(
UsernameField -> username, PasswordField -> password, RememberMeField -> isRememberMe.toString)
TestLoginController.userRepository.login(username, password) returns Left(new Error)
val result = TestLoginController.login(fakeRequest)
status(result) should be(BAD_REQUEST)
}
it should "send 400 for login with invalid form input" in {
val fakeRequest = FakeRequest().withFormUrlEncodedBody(
UsernameField -> "", PasswordField -> "", RememberMeField -> "")
val result = TestLoginController.login(fakeRequest)
status(result) should be(BAD_REQUEST)
}
}
build.sbt
gitHeadCommitSha in ThisBuild := Process("git rev-parse HEAD").lines.head
(testOptions in Test) += Tests.Argument(TestFrameworks.ScalaTest, "-h", "target/report")
org.scalastyle.sbt.ScalastylePlugin.Settings
scalacOptions := Seq("-feature")
build.scala
import com.typesafe.sbt.SbtNativePackager._
import com.typesafe.sbt.SbtScalariform._
import play.Project._
import sbt.Keys._
import sbt._
import sbtbuildinfo.Plugin._
import scala._
import scala.util.Try
import scala.Some
import de.johoop.jacoco4sbt.JacocoPlugin._
object BuildSettings {
val buildOrganization = "com.ourCompany.ourProject"
val buildVersion = "0.1-SNAPSHOT"
val buildScalaVersion = "2.10.2"
val envConfig = "-Djava.awt.headless=true -Dsbt.log.format=false -Dconfig.file=" +
Option(System.getProperty("env.config")).getOrElse("local.application")
val maxErrors = 20
// disable running browserstack tests by default. Possible options: true | false [default]
val browserstack: Boolean = Try(System.getProperty("test.browserstack").toBoolean).getOrElse(false)
val buildSettings = Defaults.defaultSettings ++ Seq (
organization := buildOrganization,
version := buildVersion,
scalaVersion := buildScalaVersion,
scalacOptions ++= Seq("-unchecked", "-optimise", "-deprecation",
"-Xcheckinit", "-encoding", "utf8", "-feature", "-Yinline-warnings",
"-Xfatal-warnings"),
javaOptions ++= Seq("-Xms512M","-Xmx1536M", "-Xss1M", "-XX:ReservedCodeCacheSize=192M",
"-XX:+CMSClassUnloadingEnabled", "-XX:MaxPermSize=512M"),
javaOptions += envConfig,
publishMavenStyle := false
)
}
object Resolvers {
val remoteRepoUrl = "ourCompany Nexus Snapshots" at "http://nexus.ci.bln.ourCompany-xxx.com/content/repositories/snapshots/"
val publishRepoUrl = "ourCompany Nexus Snapshots" at "http://nexus.ci.bln.ourCompany-xxx.com/content/repositories/snapshots/"
val releaseRepoUrl = "ourCompany Nexus Releases" at "http://nexus.ci.bln.ourCompany-xxx.com/content/repositories/releases/"
}
object Dependencies {
val ods = "de.bsmo.ourCompany-professional" % "sprprof-ws" % "2.2.1-SNAPSHOT"
val scalatest = "org.scalatest" %% "scalatest" % "2.0" % "test->*" withSources()
val mockito = "org.mockito" % "mockito-all" % "1.9.5" % "test"
val ghostDriver = "com.github.detro.ghostdriver" % "phantomjsdriver" % "1.0.3" % "test"
val cmsClient = "com.ourCompany.cms.ws.clients" % "ourCompany-cms-java-api" % "1.1.6"
val solrjClient = "org.apache.solr" % "solr-solrj" % "4.3.1" % "compile"
}
object ApplicationBuild extends Build {
import BuildSettings._
import Dependencies._
import Resolvers._
// Sub-project specific dependencies
val commonDeps = Seq(
ods,
scalatest,
mockito,
ghostDriver,
cmsClient,
jdbc,
anorm,
filters,
solrjClient,
cache
)
//val bN = settingKey[Int]("current build Number")
val gitHeadCommitSha = settingKey[String]("current git commit SHA")
val release = settingKey[Boolean]("Release")
lazy val ourProject = play.Project(
"ourProject",
path = file("."),
settings = Defaults.defaultSettings ++ buildSettings ++
Seq(libraryDependencies ++= commonDeps) ++
Seq(scalariformSettings: _*) ++
Seq(playScalaSettings: _*) ++
Seq(publishArtifact := false) ++
buildInfoSettings ++
jacoco.settings ++
Seq(
sourceGenerators in Compile <+= buildInfo,
buildInfoKeys ++= Seq[BuildInfoKey](
resolvers,
libraryDependencies in Test,
buildInfoBuildNumber,
BuildInfoKey.map(name) { case (k, v) => "project" + k.capitalize -> v.capitalize },
"envConfig" -> envConfig, // computed at project load time
BuildInfoKey.action("buildTime") {
System.currentTimeMillis
} // re-computed each time at compile
),
buildInfoPackage := "com.ourCompany.ourProject"
) ++
Seq(resolvers += remoteRepoUrl) ++
Seq(resolvers += releaseRepoUrl) ++
Seq(mappings in Universal ++= Seq(
file("ops/rpm/start-server.sh") -> "start-server.sh",
file("ops/rpm/stop-server.sh") -> "stop-server.sh"
)) ++
Seq(testOptions in Test += Tests.Argument(if(browserstack) "-n" else "-l", "com.ourCompany.ourProject.tags.BrowserStackTest"))
).settings(version <<= version in ThisBuild)
.settings(parallelExecution in jacoco.Config := false)
.settings({
if(browserstack) {
javaOptions in Test += "-Dconfig.file=conf/browserstack.application.conf"
} else {
javaOptions in Test += "-Dtest.none=true"
}
})
lazy val ourProjectPackaging = Project(
"packaging",
file("ourProjectPackaging"), settings=
Defaults.defaultSettings ++
Seq(Packaging.settings:_*) ++
Seq(resolvers += publishRepoUrl) ++
buildSettings ++
publishSetting ++
Seq(publishArtifact := false) ++
credentialsSetting
).settings(Packaging.rpmDistSettings: _*).settings(version <<= version in Rpm )
lazy val credentialsSetting = credentials += {
Seq("NEXUS_USER", "NEXUS_PASSWORD").map(k => Option(System.getenv(k))) match {
case Seq(Some(user), Some(pass)) =>
Credentials("Sonatype Nexus Repository Manager",
"nexus.ci.bln.ourCompany-xxx.com", user, pass)
case _ =>
Credentials(Path.userHome / ".ivy2" / ".credentials")
}
}
lazy val publishSetting = publishTo <<= version.apply{
v =>
val nexus = "http://nexus.ci.bln.ourCompany-xxx.com/"
if (v.trim.endsWith("SNAPSHOT"))
Some("snapshots" at nexus + "content/repositories/snapshots")
else
Some("releases" at nexus + "content/repositories/snapshots")
}
}
Sequenze of commands
Starting Play Console (play)
clean
jacoco:cover
Details
Version of Play: play 2.2.1 built with Scala 2.10.2 (running Java 1.7.0_45)
Play about:
[info] This is sbt 0.13.0
[info] The current project is {file:/home/schl14/work/ProjektName/}ProjektName 0.1-b012d0e6a2c5b4a746490c0d34856af5e7d09bb9
[info] The current project is built against Scala 2.10.2
[info] Available Plugins: play.Project, com.typesafe.sbteclipse.plugin.EclipsePlugin, org.sbtidea.SbtIdeaPlugin, com.typesafe.sbt.SbtNativePackager, com.typesafe.sbt.SbtScalariform, sbtbuildinfo.Plugin, org.scalastyle.sbt.ScalastylePlugin, de.johoop.jacoco4sbt.JacocoPlugin
[info] sbt, sbt plugins, and build definitions are using Scala 2.10.2
Question
It worked previously (as in many many commits ago) and I failed to pinpoint what changes to the sourcecode made jacoco:cover fail. What could be the cause of this behaviour?
Once solved i will cut down on the amount of unecesary info posted here! Currently its hard to determin what needs to be provided.
Related
Below is a Scala test of websocket:
import java.util.function.Consumer
import play.shaded.ahc.org.asynchttpclient.AsyncHttpClient
import play.api.inject.guice.GuiceApplicationBuilder
import play.api.test.{Helpers, TestServer, WsTestClient}
import scala.compat.java8.FutureConverters
import scala.concurrent.Await
import scala.concurrent.duration._
import org.scalatestplus.play._
class SocketTest extends PlaySpec with ScalaFutures {
"HomeController" should {
"reject a websocket flow if the origin is set incorrectly" in WsTestClient.withClient { client =>
// Pick a non standard port that will fail the (somewhat contrived) origin check...
lazy val port: Int = 31337
val app = new GuiceApplicationBuilder().build()
Helpers.running(TestServer(port, app)) {
val myPublicAddress = s"localhost:$port"
val serverURL = s"ws://$myPublicAddress/ws"
val asyncHttpClient: AsyncHttpClient = client.underlying[AsyncHttpClient]
val webSocketClient = new WebSocketClient(asyncHttpClient)
try {
val origin = "ws://example.com/ws"
val consumer: Consumer[String] = new Consumer[String] {
override def accept(message: String): Unit = println(message)
}
val listener = new WebSocketClient.LoggingListener(consumer)
val completionStage = webSocketClient.call(serverURL, origin, listener)
val f = FutureConverters.toScala(completionStage)
Await.result(f, atMost = 1000.millis)
listener.getThrowable mustBe a[IllegalStateException]
} catch {
case e: IllegalStateException =>
e mustBe an[IllegalStateException]
case e: java.util.concurrent.ExecutionException =>
val foo = e.getCause
foo mustBe an[IllegalStateException]
}
}
}
}
}
But compile is failing on line import org.scalatestplus.play._ with error :
Cannot resolve symbol scalatestplus
From https://www.playframework.com/documentation/2.8.x/ScalaTestingWithScalaTest I have added scalatest and play to build:
build.sbt:
name := "testproject"
version := "1.0"
lazy val `testproject` = (project in file(".")).enablePlugins(PlayScala)
resolvers += "scalaz-bintray" at "https://dl.bintray.com/scalaz/releases"
resolvers += "Akka Snapshot Repository" at "https://repo.akka.io/snapshots/"
scalaVersion := "2.12.2"
libraryDependencies ++= Seq( jdbc , ehcache , ws , guice , specs2 % Test)
// https://mvnrepository.com/artifact/com.typesafe.scala-logging/scala-logging
libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.9.2"
libraryDependencies ++= Seq(
"org.scalatestplus.play" %% "scalatestplus-play" % "3.0.0" % "test"
)
unmanagedResourceDirectories in Test <+= baseDirectory ( _ /"target/web/public/test" )
I've tried rebuilding the project and module in IntelliJ "build" option and "Build Option" when I right click on build.sbt but the import is not found.
sbt dist from Intellij "sbt shell" then File -> "Invalidate caches" with restart of IntelliJ seems to fix the issue
:Invalidate caches screenshot
i have a problem about running server/client using ScalaPB on spark.
its totally work fine while I running my code using "sbt run". i want running this code using spark coz next ill import my spark model to predict some label. but while I submit my jar to spark, they give me error like this.
Exception in thread "main" io.grpc.ManagedChannelProvider$ProviderNotFoundException:
No functional server found. Try adding a dependency on the grpc-netty artifact
this is my build.sbt
scalaVersion := "2.11.7"
PB.targets in Compile := Seq(
scalapb.gen() -> (sourceManaged in Compile).value
)
val scalapbVersion =
scalapb.compiler.Version.scalapbVersion
val grpcJavaVersion =
scalapb.compiler.Version.grpcJavaVersion
libraryDependencies ++= Seq(
// protobuf
"com.thesamet.scalapb" %% "scalapb-runtime" % scalapbVersion % "protobuf",
//for grpc
"io.grpc" % "grpc-netty" % grpcJavaVersion ,
"com.thesamet.scalapb" %% "scalapb-runtime-grpc" % scalapbVersion
)
assemblyMergeStrategy in assembly := {
case PathList("META-INF", xs # _*) => MergeStrategy.discard
case x => MergeStrategy.first
}
using shade still not work
assemblyShadeRules in assembly := Seq(ShadeRule.rename("com.google.**" -> "shadegoogle.#1").inAll)
and this my main
import java.util.logging.Logger
import io.grpc.{Server, ServerBuilder}
import org.apache.spark.ml.tuning.CrossValidatorModel
import org.apache.spark.sql.SparkSession
import testproto.test.{Email, EmailLabel, RouteGuideGrpc}
import scala.concurrent.{ExecutionContext, Future}
object HelloWorldServer {
private val logger = Logger.getLogger(classOf[HelloWorldServer].getName)
def main(args: Array[String]): Unit = {
val server = new HelloWorldServer(ExecutionContext.global)
server.start()
server.blockUntilShutdown()
}
private val port = 50051
}
class HelloWorldServer(executionContext: ExecutionContext) {
self =>
private[this] var server: Server = null
private def start(): Unit = {
server = ServerBuilder.forPort(HelloWorldServer.port).addService(RouteGuideGrpc.bindService(new RouteGuideImpl, executionContext)).build.start
HelloWorldServer.logger.info("Server started, listening on " + HelloWorldServer.port)
sys.addShutdownHook {
System.err.println("*** shutting down gRPC server since JVM is shutting down")
self.stop()
System.err.println("*** server shut down")
}
}
private def stop(): Unit = {
if (server != null) {
server.shutdown()
}
}
private def blockUntilShutdown(): Unit = {
if (server != null) {
server.awaitTermination()
}
}
private class RouteGuideImpl extends RouteGuideGrpc.RouteGuide {
override def getLabel(request: Email): Future[EmailLabel] = {
val replay = EmailLabel(emailId = request.emailId, label = "aaaaa")
Future.successful(replay)
}
}
}
thanks
It looks like grpc-netty is not found when an uber jar is made. Instead of using ServerBuilder, change your code to use io.grpc.netty.NettyServerBuilder.
I am trying to create an implicit encoder using Circe. However this encoder will be created using an annotation hence I am using Scalameta. Here is my code. However, the compiler complains about having an override statement within quasiquotes.
class HalResource extends StaticAnnotation {
inline def apply(defn: Any): Any = meta {
val q"..$mods class $tName (..$params) extends $template {..$stats}" = defn
q"object $tName {${createApply(tName)}}"
}
private def createApply(className: Type.Name): Defn.Def = {
q"""
import _root_.io.circe.Json
import _root_.io.circe.syntax._
import _root_.io.circe.Encoder
implicit def encoder = Encoder[$className] {
override def apply(a: $className): Json = {
val (simpleFields: Seq[Term.Param], nonSimpleFields: Seq[Term.Param]) =
params.partition(field => field.decltpe.fold(false) {
case _: Type.Name => true
case _ => false
})
val embedded: Seq[(String, Json)] = nonSimpleFields.map(field => field.name.syntax -> field.name.value.asJson)
val simpleJsonFields: Seq[(String, Json)] = simpleFields.map(field => field.name.syntax -> field.name.value.asJson)
val baseSeq: Seq[(String, Json)] = Seq(
"_links" -> Json.obj(
"href" -> Json.obj(
"self" -> Json.fromString("self_reference")
)
),
"_embedded" -> Json.fromFields(embedded),
) ++ simpleJsonFields
val result: Seq[(String, Json)] = baseSeq ++ simpleJsonFields
Json.fromFields(result)
}
}
"""
}
}
The build file is as follows:
import sbt.Keys.{scalaVersion, scalacOptions}
val circeVersion = "0.8.0"
lazy val circeDependencies = Seq(
"io.circe" %% "circe-core",
"io.circe" %% "circe-generic",
"io.circe" %% "circe-parser"
).map(_ % circeVersion)
lazy val commonSettings = Seq(
name := "Annotation",
version := "1.0",
scalaVersion := "2.12.2",
scalacOptions ++= Seq("-unchecked", "-deprecation", "-feature"),
resolvers += Resolver.sonatypeRepo("releases")
)
lazy val macroAnnotationSettings = Seq(
addCompilerPlugin("org.scalameta" % "paradise" % "3.0.0-M9" cross CrossVersion.full),
scalacOptions += "-Xplugin-require:macroparadise",
scalacOptions in (Compile, console) ~= (_ filterNot (_ contains "paradise"))
)
lazy val projectThatDefinesMacroAnnotations = project.in(file("annotation-definition"))
.settings(commonSettings)
.settings(
name := "HalResource",
libraryDependencies += "org.scalameta" %% "scalameta" % "1.8.0" % Provided,
macroAnnotationSettings)
lazy val annotation = project.in(file("."))
.settings(commonSettings)
.settings(macroAnnotationSettings)
.settings(
libraryDependencies ++= circeDependencies
).dependsOn(projectThatDefinesMacroAnnotations)
As a result I still get:
macro annotation could not be expanded (the most common reason for that is that you need to enable the macro paradise plugin; another possibility is that you try to use macro annotation in the same compilation run that defines it)
You are just missing new before Encoder[$className] { (there may be other errors, but that's the immediate one).
Because of this, the compiler thinks you are trying to call a generic method Encoder with the block
{
override def apply(a: $className): Json = ...
...
}
as the argument, and local methods can't be override.
I am trying to learn about Akka actors and I am running the following example. My problem is that when I run though the Idea IDE it works perfectly fine. But when I run it using the jar created by sbt assembly it throws a NoSuchMethodException java.lang.NoSuchMethodError: akka.actor.ActorSystem.dispatcher()Lscala/concurrent/ExecutionContextExecutor Exception which I cannot debug because it works fine in the IDE.
object Runner {
def main(args: Array[String]) {
run()
}
def run() = {
val system = ActorSystem("my-system")
import system.dispatcher
val props = Props[Manager]
val pool = mutable.ArrayBuffer.empty[(Int, ActorRef)]
for (i <- 1 to 10) {
pool += ((i, system.actorOf(props)))
}
val futures = pool.map {
case (x: Int, y: ActorRef) =>
val future = ask(y, Echo(x))(Timeout(100 seconds)).mapTo[Int]
println(future.toString)
future
}
/*Next line causes Exception*/
val futureList = Future.sequence(futures)
val result = futureList.map(x => {
x.sum
})
result onSuccess {
case sum => println(sum)
}
pool.foreach(x => system.stop(x._2))
system.shutdown()
}
}
The sbt file I am using is the following.
lazy val commonSettings = Seq(
organization := "foobar",
version := "1.0",
scalaVersion := "2.10.6",
test in assembly := {}
)
lazy val root = (project).aggregate(redis).settings(commonSettings: _*).
settings(
name := "scala_code_root",
version := "1.0",
scalaVersion := "2.10.6"
exportJars := false
)
lazy val myakka =(project in file("myakka")).settings(commonSettings: _*).settings(
libraryDependencies += "com.typesafe.akka" % "akka-actor_2.10" % "2.3.15"
)
The exception is thrown at the line val futureList = Future.sequence(futures). Apparently the method is trere because both IDEA and sbt-assembly use the same sbt file. What could be the cause of the Exception?
We need a base play framework projects which contains other play and scala projects as module. Those inner independent projects can have different javascript frameworks and build system like webpack, gulp, etc.
So I tried the PlayRunHook from https://www.playframework.com/documentation/2.4.x/SBTCookbook . Single project hooking working as expected. But, unable to get it right on multi module project. Some code samples...
Project Structure
base/build.sbt
name := """base"""
version := "1.0-SNAPSHOT"
lazy val commonSettings = Seq(
scalaVersion := "2.11.6",
libraryDependencies ++= Seq(
jdbc,
cache,
ws,
specs2 % Test
),
resolvers ++= Seq(
"scalaz-bintray" at "http://dl.bintray.com/scalaz/releases"
)
)
lazy val root = (project in file("."))
.settings(commonSettings : _*)
.enablePlugins(PlayScala)
.dependsOn(scraper)
.aggregate(scraper)
.dependsOn(slider)
.aggregate(slider)
lazy val scraper = (project in file("modules/scraper"))
.settings(commonSettings : _*)
.enablePlugins(PlayScala)
lazy val slider = (project in file("modules/slider"))
.settings(commonSettings : _*)
.enablePlugins(PlayScala)
routesGenerator := InjectedRoutesGenerator
base/modules/scraper/build.sbt
import play.sbt.PlayImport.PlayKeys.playRunHooks
import WebPack._
name := """scraper"""
version := "1.0-SNAPSHOT"
lazy val frontendDirectory = baseDirectory {_ / "frontend"}
playRunHooks <+= frontendDirectory.map(WebPack.apply)
routesGenerator := InjectedRoutesGenerator
libraryDependencies ++= Seq(
"com.corundumstudio.socketio" % "netty-socketio" % "1.7.8"
)
resolvers ++= Seq(
"Sonatype OSS Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots"
)
base/modules/slider/build.sbt
name := """slider"""
version := "1.0-SNAPSHOT"
scalaVersion := "2.11.6"
routesGenerator := InjectedRoutesGenerator
base/modules/scraper/project/WebPack.scala
import java.net.InetSocketAddress
import play.sbt.PlayRunHook
import sbt._
object WebPack {
def apply(base: File): PlayRunHook = {
object WebpackHook extends PlayRunHook {
var process: Option[Process] = None
override def beforeStarted(): Unit = {
if (isWindows) {
Process("cmd /c npm run compile", base).run
} else {
Process("npm run compile", base).run
}
}
override def afterStarted(addr: InetSocketAddress): Unit = {
if (isWindows) {
Some(Process("cmd /c npm start", base).run)
} else {
Some(Process("npm start", base).run)
}
}
private def isWindows: Boolean = {
System.getProperty("os.name").startsWith("Windows")
}
override def afterStopped(): Unit = {
process.foreach(_.destroy())
process = None
}
}
WebpackHook
}
}
But I am getting
...../base/modules/scraper/build.sbt:10: error: not found: object WebPack
import WebPack._
^
sbt.compiler.EvalException: Type error in expression
at sbt.compiler.Eval.checkError(Eval.scala:384)
at sbt.compiler.Eval.compileAndLoad(Eval.scala:183)
at sbt.compiler.Eval.evalCommon(Eval.scala:152)
at sbt.compiler.Eval.evalDefinitions(Eval.scala:122)
at sbt.EvaluateConfigurations$.evaluateDefinitions(EvaluateConfigurations.scala:271)
at sbt.EvaluateConfigurations$.evaluateSbtFile(EvaluateConfigurations.scala:109)
at sbt.Load$.sbt$Load$$loadSettingsFile$1(Load.scala:712)
at sbt.Load$$anonfun$sbt$Load$$memoLoadSettingsFile$1$1.apply(Load.scala:717)
at sbt.Load$$anonfun$sbt$Load$$memoLoadSettingsFile$1$1.apply(Load.scala:716)
at scala.collection.MapLike$class.getOrElse(MapLike.scala:128)
at scala.collection.AbstractMap.getOrElse(Map.scala:58)
at sbt.Load$.sbt$Load$$memoLoadSettingsFile$1(Load.scala:716)
at sbt.Load$$anonfun$loadFiles$1$2.apply(Load.scala:723)
at sbt.Load$$anonfun$loadFiles$1$2.apply(Load.scala:723)
at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:244)
at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:244)
at scala.collection.immutable.List.foreach(List.scala:318)
at scala.collection.TraversableLike$class.map(TraversableLike.scala:244)
at scala.collection.AbstractTraversable.map(Traversable.scala:105)
at sbt.Load$.loadFiles$1(Load.scala:723)
at sbt.Load$.discoverProjects(Load.scala:734)
at sbt.Load$.discover$1(Load.scala:545)
at sbt.Load$.discoverAndLoad$1(Load.scala:554)
at sbt.Load$.loadTransitive(Load.scala:570)
at sbt.Load$.loadProjects$1(Load.scala:442)
at sbt.Load$.loadUnit(Load.scala:446)
at sbt.Load$$anonfun$18$$anonfun$apply$11.apply(Load.scala:281)
at sbt.Load$$anonfun$18$$anonfun$apply$11.apply(Load.scala:281)
at sbt.BuildLoader$$anonfun$componentLoader$1$$anonfun$apply$4$$anonfun$apply$5$$anonfun$apply$6.apply(BuildLoader.scala:91)
at sbt.BuildLoader$$anonfun$componentLoader$1$$anonfun$apply$4$$anonfun$apply$5$$anonfun$apply$6.apply(BuildLoader.scala:90)
at sbt.BuildLoader.apply(BuildLoader.scala:140)
at sbt.Load$.loadAll(Load.scala:334)
at sbt.Load$.loadURI(Load.scala:289)
at sbt.Load$.load(Load.scala:285)
at sbt.Load$.load(Load.scala:276)
at sbt.Load$.apply(Load.scala:130)
at sbt.Load$.defaultLoad(Load.scala:36)
at sbt.BuiltinCommands$.doLoadProject(Main.scala:481)
at sbt.BuiltinCommands$$anonfun$loadProjectImpl$2.apply(Main.scala:475)
at sbt.BuiltinCommands$$anonfun$loadProjectImpl$2.apply(Main.scala:475)
at sbt.Command$$anonfun$applyEffect$1$$anonfun$apply$2.apply(Command.scala:58)
at sbt.Command$$anonfun$applyEffect$1$$anonfun$apply$2.apply(Command.scala:58)
at sbt.Command$$anonfun$applyEffect$2$$anonfun$apply$3.apply(Command.scala:60)
at sbt.Command$$anonfun$applyEffect$2$$anonfun$apply$3.apply(Command.scala:60)
at sbt.Command$.process(Command.scala:92)
at sbt.MainLoop$$anonfun$1$$anonfun$apply$1.apply(MainLoop.scala:98)
at sbt.MainLoop$$anonfun$1$$anonfun$apply$1.apply(MainLoop.scala:98)
at sbt.State$$anon$1.process(State.scala:184)
at sbt.MainLoop$$anonfun$1.apply(MainLoop.scala:98)
at sbt.MainLoop$$anonfun$1.apply(MainLoop.scala:98)
at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:17)
at sbt.MainLoop$.next(MainLoop.scala:98)
at sbt.MainLoop$.run(MainLoop.scala:91)
at sbt.MainLoop$$anonfun$runWithNewLog$1.apply(MainLoop.scala:70)
at sbt.MainLoop$$anonfun$runWithNewLog$1.apply(MainLoop.scala:65)
at sbt.Using.apply(Using.scala:24)
at sbt.MainLoop$.runWithNewLog(MainLoop.scala:65)
at sbt.MainLoop$.runAndClearLast(MainLoop.scala:48)
at sbt.MainLoop$.runLoggedLoop(MainLoop.scala:32)
at sbt.MainLoop$.runLogged(MainLoop.scala:24)
at sbt.StandardMain$.runManaged(Main.scala:53)
at sbt.xMain.run(Main.scala:28)
at xsbt.boot.Launch$$anonfun$run$1.apply(Launch.scala:109)
at xsbt.boot.Launch$.withContextLoader(Launch.scala:128)
at xsbt.boot.Launch$.run(Launch.scala:109)
at xsbt.boot.Launch$$anonfun$apply$1.apply(Launch.scala:35)
at xsbt.boot.Launch$.launch(Launch.scala:117)
at xsbt.boot.Launch$.apply(Launch.scala:18)
at xsbt.boot.Boot$.runImpl(Boot.scala:41)
at xsbt.boot.Boot$.main(Boot.scala:17)
at xsbt.boot.Boot.main(Boot.scala)
[error] sbt.compiler.EvalException: Type error in expression
[error] Use 'last' for the full log.
Project loading failed: (r)etry, (q)uit, (l)ast, or (i)gnore?
I am experimenting play framework, and I am fairly new to this. Thanks in advance
In sbt keep only one build.sbt file and one project directory (with *.sbt and *.scala config files)
Copy WebPack.scala to project directory.
Move your root project to subproject (base).
Rewrite build.sbt
import play.sbt.PlayImport.PlayKeys.playRunHooks
name := """root"""
version := "1.0-SNAPSHOT"
val scraperDir = "modules/scraper"
val sliderDir = "modules/slider"
lazy val commonSettings = Seq(
scalaVersion := "2.11.7",
libraryDependencies ++= Seq(
jdbc,
cache,
ws,
specs2 % Test
),
resolvers ++= Seq(
"scalaz-bintray" at "http://dl.bintray.com/scalaz/releases"
)
)
lazy val base = projectName("base","base").settings(
playRunHooks += WebPack.apply(file(scraperDir))
)
.dependsOn(scraper,slider)
lazy val scraper = projectName("scraper", scraperDir).settings(
libraryDependencies ++= Seq(
"com.corundumstudio.socketio" % "netty-socketio" % "1.7.8"
),
resolvers ++= Seq(
"Sonatype OSS Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots")
)
lazy val slider = projectName("slider", sliderDir)
def projectName(name: String, path: String): Project =
Project(name,file(path))
.settings(
commonSettings,
routesGenerator := InjectedRoutesGenerator
)
.enablePlugins(PlayScala)