play.api.libs.json.JsPath Scala Examples
The following examples show how to use play.api.libs.json.JsPath.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
Example 1
| Source File: PipelineClass.scala From daf with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
package it.gov.daf.ingestion.pipelines.data
import ingestion_manager.yaml.PipelineInfo
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Reads}
object PipelineClass {
implicit val pipelineInfoReads: Reads[PipelineInfo] = (
(JsPath \ "name").read[String] and
(JsPath \ "description").read[String] and
(JsPath \ "id").read[String] and
(JsPath \ "default_stream").read[Boolean] and
(JsPath \ "category").read[String] and
(JsPath \ "default_batch").read[Boolean]
)(PipelineInfo.apply _)
}
Example 2
| Source File: Node.scala From cluster-broccoli with Apache License 2.0 | 5 votes |
|
package de.frosner.broccoli.nomad.models
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Reads}
import shapeless.tag
import shapeless.tag.@@
final case class Node(
id: String @@ Node.Id,
name: String @@ Node.Name,
httpAddress: String @@ Node.HttpAddress
)
object Node {
sealed trait Id
sealed trait Name
sealed trait HttpAddress
implicit val nodeReads: Reads[Node] = (
(JsPath \ "ID").read[String].map(tag[Id](_)) and
(JsPath \ "Name").read[String].map(tag[Name](_)) and
(JsPath \ "HTTPAddr").read[String].map(tag[HttpAddress](_))
)(Node.apply _)
}
Example 3
package libs.ziohelper
import cats.data.NonEmptyList
import play.api.libs.json.{JsError, JsPath, JsResult, JsSuccess, JsonValidationError}
import domains.errors.{IzanamiErrors, ValidationError}
import zio._
import libs.logs.ZLogger
object JsResults {
def handleJsError[C <: ZLogger, T](err: Seq[(JsPath, Seq[JsonValidationError])]): ZIO[C, IzanamiErrors, T] =
ZLogger.error(s"Error parsing json $err") *>
IO.fail(NonEmptyList.of(ValidationError.error("error.json.parsing")))
def jsResultToError[C <: ZLogger, T](jsResult: JsResult[T]): ZIO[C, IzanamiErrors, T] =
fromJsResult(jsResult) { handleJsError }
def jsResultToHttpResponse[T](jsResult: JsResult[T]) =
liftJsResult(jsResult)(err => play.api.mvc.Results.BadRequest(ValidationError.fromJsError(err).toJson))
def liftJsResult[T, E](jsResult: JsResult[T])(onError: Seq[(JsPath, Seq[JsonValidationError])] => E): IO[E, T] =
jsResult match {
case JsSuccess(value, _) => IO.succeed(value)
case JsError(errors) => IO.fail(onError(errors.toSeq.map(t => t.copy(_2 = t._2.toSeq))))
}
def fromJsResult[C <: ZLogger, T, E](
jsResult: JsResult[T]
)(onError: Seq[(JsPath, Seq[JsonValidationError])] => ZIO[C, E, T]): ZIO[C, E, T] =
jsResult match {
case JsSuccess(value, _) => ZIO.succeed(value)
case JsError(errors) => onError(errors.toSeq.map(t => t.copy(_2 = t._2.toSeq)))
}
}
Example 4
| Source File: HatClaims.scala From HAT2.0 with GNU Affero General Public License v3.0 | 5 votes |
|
package org.hatdex.hat.phata.models
import play.api.libs.json.{ JsPath, Json, Reads, Writes }
import play.api.libs.functional.syntax._
case class ApiClaimHatRequest(applicationId: String, email: String)
object ApiClaimHatRequest {
implicit val claimHatRequestApiReads: Reads[ApiClaimHatRequest] = (
(JsPath \ "applicationId").read[String] and (JsPath \ "email").read[String](Reads.email))(ApiClaimHatRequest.apply _)
implicit val claimHatRequestApiWrites: Writes[ApiClaimHatRequest] = Json.format[ApiClaimHatRequest]
}
case class HatClaimCompleteRequest(
email: String,
termsAgreed: Boolean,
optins: Array[String],
hatName: String,
hatCluster: String,
password: String)
case class HattersClaimPayload(
email: String,
termsAgreed: Boolean,
sandbox: Boolean,
platform: String,
newsletterOptin: Option[Boolean],
hatName: String,
hatCluster: String)
object HatClaimCompleteRequest {
implicit val hatClaimRequestReads: Reads[HatClaimCompleteRequest] = Json.reads[HatClaimCompleteRequest]
}
object HattersClaimPayload {
def apply(claim: HatClaimCompleteRequest): HattersClaimPayload = new HattersClaimPayload(
claim.email, claim.termsAgreed, claim.hatCluster == "hubat.net", "web", Some(claim.optins.nonEmpty), claim.hatName, claim.hatCluster)
implicit val HatClaimRequestWrites: Writes[HattersClaimPayload] = Json.format[HattersClaimPayload]
}
Example 5
| Source File: GraphQlClient.scala From graphcool-framework with Apache License 2.0 | 5 votes |
|
package cool.graph.graphql
import akka.http.scaladsl.Http
import akka.stream.ActorMaterializer
import cool.graph.akkautil.SingleThreadedActorSystem
import play.api.libs.json.{JsPath, JsValue, Json, Reads}
import scala.concurrent.Future
import scala.util.{Failure, Success, Try}
trait GraphQlClient {
def sendQuery(query: String): Future[GraphQlResponse]
}
object GraphQlClient {
private implicit lazy val actorSystem = SingleThreadedActorSystem("graphql-client")
private implicit lazy val actorMaterializer = ActorMaterializer()(actorSystem)
private implicit lazy val akkaHttp = Http()(actorSystem)
def apply(uri: String, headers: Map[String, String] = Map.empty): GraphQlClient = {
GraphQlClientImpl(uri, headers, akkaHttp)
}
}
case class GraphQlResponse(status: Int, body: String) {
def bodyAs[T](path: String)(implicit reads: Reads[T]): Try[T] = {
def jsPathForElements(pathElements: Seq[String], current: JsPath = JsPath()): JsPath = {
if (pathElements.isEmpty) {
current
} else {
jsPathForElements(pathElements.tail, current \ pathElements.head)
}
}
val jsPath = jsPathForElements(path.split('.'))
val actualReads = jsPath.read(reads)
jsonBody.map(_.as(actualReads))
}
val is2xx: Boolean = status >= 200 && status <= 299
val is200: Boolean = status == 200
val is404: Boolean = status == 404
def isSuccess: Boolean = deserializedBody match {
case Success(x) => x.errors.isEmpty && is200
case Failure(e) => false
}
def isFailure: Boolean = !isSuccess
def firstError: GraphQlError = deserializedBody.get.errors.head
private lazy val deserializedBody: Try[GraphQlResponseJson] = {
for {
body <- jsonBody
response <- Try { body.as(JsonReaders.graphqlResponseReads) }
} yield response
}
lazy val jsonBody: Try[JsValue] = Try(Json.parse(body))
}
case class GraphQlResponseJson(data: JsValue, errors: Seq[GraphQlError])
case class GraphQlError(message: String, code: Int)
object JsonReaders {
import play.api.libs.functional.syntax._
import play.api.libs.json._
implicit lazy val graphqlErrorReads = Json.reads[GraphQlError]
implicit lazy val graphqlResponseReads = (
(JsPath \ "data").read[JsValue] and
(JsPath \ "errors").readNullable[Seq[GraphQlError]].map(_.getOrElse(Seq.empty))
)(GraphQlResponseJson.apply _)
}
Example 6
| Source File: package.scala From skuber with Apache License 2.0 | 5 votes |
|
package skuber.json.batch
import play.api.libs.json.{Format, JsPath, Json}
import skuber.batch.{Job, JobList, JobTemplate, CronJob, CronJobList}
import play.api.libs.functional.syntax._
import skuber._
import skuber.json.format._ // reuse some core formatters
package object format {
// Job formatters
implicit val jobConditionFormat: Format[Job.Condition] = (
(JsPath \ "type").formatMaybeEmptyString() and
(JsPath \ "status").formatMaybeEmptyString() and
(JsPath \ "lastProbeTime").formatNullable[Timestamp] and
(JsPath \ "lastTransitionTime").formatNullable[Timestamp] and
(JsPath \ "reason").formatNullable[String] and
(JsPath \ "message").formatNullable[String]
)(Job.Condition.apply _, unlift(Job.Condition.unapply))
implicit val jobStatusFormat: Format[Job.Status] = (
(JsPath \ "conditions").formatMaybeEmptyList[Job.Condition] and
(JsPath \ "startTime").formatNullable[Timestamp] and
(JsPath \ "completionTime").formatNullable[Timestamp] and
(JsPath \ "active").formatNullable[Int] and
(JsPath \ "succeeded").formatNullable[Int] and
(JsPath \ "failed").formatNullable[Int]
)(Job.Status.apply _, unlift(Job.Status.unapply))
implicit val jobSpecFormat: Format[Job.Spec] = (
(JsPath \ "parallelism").formatNullable[Int] and
(JsPath \ "completions").formatNullable[Int] and
(JsPath \ "activeDeadlineSeconds").formatNullable[Long] and
(JsPath \ "selector").formatNullableLabelSelector and
(JsPath \ "manualSelector").formatNullable[Boolean] and
(JsPath \ "template").formatNullable[Pod.Template.Spec] and
(JsPath \ "backoffLimit").formatNullable[Int] and
(JsPath \ "ttlSecondsAfterFinished").formatNullable[Int]
)(Job.Spec.apply _, unlift(Job.Spec.unapply))
implicit val jobFormat: Format[Job] = (
(JsPath \ "kind").formatMaybeEmptyString() and
(JsPath \ "apiVersion").formatMaybeEmptyString() and
(JsPath \ "metadata").format[ObjectMeta] and
(JsPath \ "spec").formatNullable[Job.Spec] and
(JsPath \ "status").formatNullable[Job.Status]
)(Job.apply _, unlift(Job.unapply))
implicit val jobTmplSpecFmt: Format[JobTemplate.Spec] = Json.format[JobTemplate.Spec]
implicit val cronJobSpecFmt:Format[CronJob.Spec] = Json.format[CronJob.Spec]
implicit val cronJobStatusFmt: Format[CronJob.Status] = (
(JsPath \ "lastScheduleTime").formatNullable[Timestamp] and
(JsPath \ "active").formatMaybeEmptyList[ObjectReference]
)(CronJob.Status.apply _, unlift(CronJob.Status.unapply))
implicit val cronJob: Format[CronJob] = (
(JsPath \ "kind").formatMaybeEmptyString() and
(JsPath \ "apiVersion").formatMaybeEmptyString() and
(JsPath \ "metadata").format[ObjectMeta] and
(JsPath \ "spec").formatNullable[CronJob.Spec] and
(JsPath \ "status").formatNullable[CronJob.Status]
)(CronJob.apply _, unlift(CronJob.unapply))
implicit val jobListFmt: Format[JobList] = ListResourceFormat[Job]
implicit val cronJobListFmt: Format[CronJobList] = ListResourceFormat[CronJob]
}
Example 7
| Source File: PodDisruptionBudget.scala From skuber with Apache License 2.0 | 5 votes |
|
package skuber.policy.v1beta1
import skuber.ResourceSpecification.{Names, Scope}
import skuber.{IntOrString, LabelSelector, NonCoreResourceSpecification, ObjectMeta, ObjectResource, ResourceDefinition, Scale, Timestamp}
case class PodDisruptionBudget(override val kind: String = "PodDisruptionBudget",
override val apiVersion: String = policyAPIVersion,
metadata: ObjectMeta,
spec: Option[PodDisruptionBudget.Spec] = None,
status: Option[PodDisruptionBudget.Status] = None) extends ObjectResource {
private lazy val copySpec: PodDisruptionBudget.Spec = this.spec.getOrElse(PodDisruptionBudget.Spec(selector=Some(LabelSelector())))
def withLabelSelector(sel: LabelSelector): PodDisruptionBudget = {
this.copy(spec = Some(copySpec.copy(selector = Some(sel))))
}
def withMaxUnavailable(value: IntOrString): PodDisruptionBudget = {
this.copy(spec = Some(copySpec.copy(maxUnavailable = Some(value))))
}
def withMinAvailable(value: IntOrString): PodDisruptionBudget = {
this.copy(spec = Some(copySpec.copy(minAvailable = Some(value))))
}
}
object PodDisruptionBudget {
def apply(name: String): PodDisruptionBudget = {
PodDisruptionBudget(metadata = ObjectMeta(name = name))
}
val specification = NonCoreResourceSpecification(
apiGroup = "policy",
version = "v1beta1",
scope = Scope.Namespaced,
names = Names(
plural = "poddisruptionbudgets",
singular = "poddisruptionbudget",
kind = "PodDisruptionBudget",
shortNames = List("pdb")
)
)
implicit val stsDef: ResourceDefinition[PodDisruptionBudget] = new ResourceDefinition[PodDisruptionBudget] {
def spec: NonCoreResourceSpecification = specification
}
implicit val stsListDef: ResourceDefinition[PodDisruptionBudgetList] = new ResourceDefinition[PodDisruptionBudgetList] {
def spec: NonCoreResourceSpecification = specification
}
case class Spec(maxUnavailable: Option[IntOrString] = None,
minAvailable: Option[IntOrString] = None,
selector: Option[LabelSelector] = None)
case class Status(currentHealthy: Int,
desiredHealthy: Int,
disruptedPods: Map[String, Timestamp],
disruptionsAllowed: Int,
expectedPods: Int,
observedGeneration: Option[Int])
import play.api.libs.functional.syntax._
import play.api.libs.json.{Format, JsPath}
import skuber.json.format._
implicit val depStatusFmt: Format[Status] = (
(JsPath \ "currentHealthy").formatMaybeEmptyInt() and
(JsPath \ "desiredHealthy").formatMaybeEmptyInt() and
(JsPath \ "disruptedPods").formatMaybeEmptyMap[Timestamp] and
(JsPath \ "disruptionsAllowed").formatMaybeEmptyInt() and
(JsPath \ "expectedPods").formatMaybeEmptyInt() and
(JsPath \ "observedGeneration").formatNullable[Int]
) (Status.apply, unlift(Status.unapply))
implicit val depSpecFmt: Format[Spec] = (
(JsPath \ "maxUnavailable").formatNullable[IntOrString] and
(JsPath \ "minAvailable").formatNullable[IntOrString] and
(JsPath \ "selector").formatNullableLabelSelector
) (Spec.apply, unlift(Spec.unapply))
implicit lazy val pdbFormat: Format[PodDisruptionBudget] = (
objFormat and
(JsPath \ "spec").formatNullable[Spec] and
(JsPath \ "status").formatNullable[Status]
)(PodDisruptionBudget.apply, unlift(PodDisruptionBudget.unapply))
implicit val pdbListFormat: Format[PodDisruptionBudgetList] = ListResourceFormat[PodDisruptionBudget]
}
Example 8
| Source File: PodPreset.scala From skuber with Apache License 2.0 | 5 votes |
|
package skuber.settings
import play.api.libs.functional.syntax._
import play.api.libs.json.{Format, JsPath}
import skuber.json.format.{objFormat,maybeEmptyFormatMethods,jsPath2LabelSelFormat,envVarFormat,envFromSourceFmt, volMountFormat, volumeFormat}
import skuber.ResourceSpecification.{Names, Scope}
import skuber.{EnvFromSource, EnvVar, LabelSelector, NonCoreResourceSpecification, ObjectMeta, ObjectResource, ResourceDefinition, Volume}
case class PodPreset(
val kind: String ="PodPreset",
override val apiVersion: String = "settings.k8s.io/v1alpha1",
val metadata: ObjectMeta,
spec: Option[PodPreset.Spec]=None) extends ObjectResource
object PodPreset {
case class Spec(
selector: LabelSelector,
env: List[EnvVar] = Nil,
envFrom: List[EnvFromSource] = Nil,
volumes: List[Volume] = Nil,
volumeMounts: List[Volume.Mount] = Nil
)
// Kubernetes resource specification
val specification = NonCoreResourceSpecification(
apiGroup ="settings.k8s.io",
version = "v1alpha1",
scope = Scope.Namespaced,
names = Names(
plural = "podpresets",
singular = "podpreset",
kind = "PodPreset",
shortNames = List()
)
)
implicit val ppDef = new ResourceDefinition[PodPreset] { def spec = specification }
implicit val pplListDef = new ResourceDefinition[PodPresetList] { def spec = specification }
// Json formatters
implicit val podPresetSpecFmt: Format[Spec] = (
(JsPath \ "selector").formatLabelSelector and
(JsPath \ "env").formatMaybeEmptyList[EnvVar] and
(JsPath \ "envFrom").formatMaybeEmptyList[EnvFromSource] and
(JsPath \ "volumes").formatMaybeEmptyList[Volume] and
(JsPath \ "volumeMounts").formatMaybeEmptyList[Volume.Mount]
)(Spec.apply _, unlift(Spec.unapply))
implicit val podPresetFmt: Format[PodPreset] = (
objFormat and
(JsPath \ "spec").formatNullable[Spec]
)(PodPreset.apply _, unlift(PodPreset.unapply))
}
Example 9
| Source File: Scale.scala From skuber with Apache License 2.0 | 5 votes |
|
package skuber
import play.api.libs.functional.syntax._
import play.api.libs.json.{Format, JsPath, Json}
import skuber.json.format.{maybeEmptyFormatMethods,jsPath2LabelSelFormat,objectMetaFormat}
case class Scale(
val kind: String = "Scale",
val apiVersion: String,
val metadata: ObjectMeta,
spec: Scale.Spec = Scale.Spec(),
status: Option[Scale.Status] = None) extends ObjectResource
{
def withSpecReplicas(count: Int) = this.copy(spec=Scale.Spec(Some(count)))
def withStatusReplicas(count: Int) = {
val newStatus = this.status.map(_.copy(replicas = count)).getOrElse(Scale.Status(replicas=count))
this.copy(status=Some(newStatus))
}
}
object Scale {
def named(name: String, apiVersion: String=v1) = new Scale(apiVersion=apiVersion,metadata=ObjectMeta(name=name))
case class Spec(replicas: Option[Int] = None)
object Spec {
implicit val scaleSpecFormat: Format[Scale.Spec] = Json.format[Scale.Spec]
}
case class Status(
replicas: Int = 0,
selector: Option[LabelSelector] = None,
targetSelector: Option[String] = None
)
object Status {
implicit val scaleStatusFormat: Format[Scale.Status] = (
(JsPath \ "replicas").formatMaybeEmptyInt() and
(JsPath \ "selector").formatNullableLabelSelector and
(JsPath \ "targetSelector").formatNullable[String]
)(Scale.Status.apply _, unlift(Scale.Status.unapply))
}
implicit val scaleFormat: Format[Scale] = Json.format[Scale]
// Any object resource type [O <: ObjectResource] that supports a Scale subresource must provide an implicit value of
// SubresourceSpec type to enable the client API method `scale` to be used on such resources
// Kubernetes supports Scale subresources on ReplicationController/ReplicaSet/Deployment/StatefulSet types
trait SubresourceSpec[O <: ObjectResource] {
def apiVersion: String // the API version to be set on any Scale subresource of the specific resource type O
}
}
Example 10
| Source File: HeaderSpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5
import org.scalatest.{Matchers, FunSpec}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json, JsValue}
class HeaderSpec extends FunSpec with Matchers {
val headerJson: JsValue = Json.parse("""
{
"msg_id": "<UUID>",
"username": "<STRING>",
"session": "<UUID>",
"msg_type": "<STRING>",
"version": "<FLOAT>"
}
""")
val header: Header = Header(
"<UUID>", "<STRING>", "<UUID>", "<STRING>", "<FLOAT>"
)
describe("Header") {
describe("when null") {
it("should implicitly convert to empty json") {
val header: Header = null
Json.toJson(header).toString() should be ("{}")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a header instance") {
// This is the least safe way to convert as an error is thrown if it fails
headerJson.as[Header] should be (header)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newHeader = headerJson.asOpt[Header]
newHeader.get should be (header)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val headerResults = headerJson.validate[Header]
headerResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: Header) => valid
) should be (header)
}
it("should implicitly convert from a header instance to valid json") {
Json.toJson(header) should be (headerJson)
}
}
}
}
Example 11
| Source File: ConnectReplySpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.content
import org.scalatest.{FunSpec, Matchers}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class ConnectReplySpec extends FunSpec with Matchers {
val connectReplyJson: JsValue = Json.parse("""
{
"shell_port": 11111,
"iopub_port": 22222,
"stdin_port": 33333,
"hb_port": 44444
}
""")
val connectReply: ConnectReply = ConnectReply(11111,22222,33333,44444)
describe("ConnectReply") {
describe("#toTypeString") {
it("should return correct type") {
ConnectReply.toTypeString should be ("connect_reply")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a ConnectReply instance") {
// This is the least safe way to convert as an error is thrown if it fails
connectReplyJson.as[ConnectReply] should be (connectReply)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newConnectReply = connectReplyJson.asOpt[ConnectReply]
newConnectReply.get should be (connectReply)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val ConnectReplyResults = connectReplyJson.validate[ConnectReply]
ConnectReplyResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: ConnectReply) => valid
) should be (connectReply)
}
it("should implicitly convert from a ConnectReply instance to valid json") {
Json.toJson(connectReply) should be (connectReplyJson)
}
}
}
}
Example 12
| Source File: CompleteReplySpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.content
import org.scalatest.{Matchers, FunSpec}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class CompleteReplySpec extends FunSpec with Matchers {
val completeReplyJson: JsValue = Json.parse("""
{
"matches": [],
"cursor_start": 1,
"cursor_end": 5,
"metadata": {},
"status": "<STRING>"
}
""")
val completeReply: CompleteReply = CompleteReply(
List(), 1, 5, Map(), "<STRING>", None, None, None
)
describe("CompleteReply") {
describe("#toTypeString") {
it("should return correct type") {
CompleteReply.toTypeString should be ("complete_reply")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a CompleteReply instance") {
// This is the least safe way to convert as an error is thrown if it fails
completeReplyJson.as[CompleteReply] should be (completeReply)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newCompleteReply = completeReplyJson.asOpt[CompleteReply]
newCompleteReply.get should be (completeReply)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val CompleteReplyResults = completeReplyJson.validate[CompleteReply]
CompleteReplyResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: CompleteReply) => valid
) should be (completeReply)
}
it("should implicitly convert from a CompleteReply instance to valid json") {
Json.toJson(completeReply) should be (completeReplyJson)
}
}
}
}
Example 13
| Source File: KernelStatusSpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.content
import org.scalatest.{FunSpec, Matchers}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class KernelStatusSpec extends FunSpec with Matchers {
val kernelStatusJson: JsValue = Json.parse("""
{
"execution_state": "<STRING>"
}
""")
val kernelStatus: KernelStatus = KernelStatus("<STRING>")
describe("KernelStatus") {
describe("#toTypeString") {
it("should return correct type") {
KernelStatus.toTypeString should be ("status")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a kernelStatus instance") {
// This is the least safe way to convert as an error is thrown if it fails
kernelStatusJson.as[KernelStatus] should be (kernelStatus)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newKernelStatus = kernelStatusJson.asOpt[KernelStatus]
newKernelStatus.get should be (kernelStatus)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val kernelStatusResults = kernelStatusJson.validate[KernelStatus]
kernelStatusResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: KernelStatus) => valid
) should be (kernelStatus)
}
it("should implicitly convert from a kernelStatus instance to valid json") {
Json.toJson(kernelStatus) should be (kernelStatusJson)
}
}
}
}
Example 14
| Source File: Utilities.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.client
import java.nio.charset.Charset
import akka.util.{ByteString, Timeout}
import org.apache.toree.communication.ZMQMessage
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.kernel.protocol.v5.content.ExecuteRequest
import org.apache.toree.utils.LogLike
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json, Reads}
import scala.concurrent.duration._
object Utilities extends LogLike {
//
// NOTE: This is brought in to remove feature warnings regarding the use of
// implicit conversions regarding the following:
//
// 1. ByteStringToString
// 2. ZMQMessageToKernelMessage
//
import scala.language.implicitConversions
private val sessionId: UUID = java.util.UUID.randomUUID().toString
implicit val timeout = Timeout(21474835.seconds) // Maximum delay
implicit def ByteStringToString(byteString : ByteString) : String = {
new String(byteString.toArray, Charset.forName("UTF-8"))
}
implicit def StringToByteString(string : String) : ByteString = {
ByteString(string.getBytes)
}
implicit def ZMQMessageToKernelMessage(message: ZMQMessage): KernelMessage = {
val delimiterIndex: Int =
message.frames.indexOf(ByteString("<IDS|MSG>".getBytes))
// TODO Handle the case where there is no delimiter
val ids: Seq[Array[Byte]] =
message.frames.take(delimiterIndex).map(
(byteString : ByteString) => { byteString.toArray }
)
val header = Json.parse(message.frames(delimiterIndex + 2)).as[Header]
val parentHeader = Json.parse(message.frames(delimiterIndex + 3)).validate[ParentHeader].fold[ParentHeader](
// TODO: Investigate better solution than setting parentHeader to null for {}
(invalid: Seq[(JsPath, Seq[ValidationError])]) => null, //HeaderBuilder.empty,
(valid: ParentHeader) => valid
)
val metadata = Json.parse(message.frames(delimiterIndex + 4)).as[Metadata]
KMBuilder().withIds(ids.toList)
.withSignature(message.frame(delimiterIndex + 1))
.withHeader(header)
.withParentHeader(parentHeader)
.withMetadata(metadata)
.withContentString(message.frame(delimiterIndex + 5)).build(false)
}
implicit def KernelMessageToZMQMessage(kernelMessage : KernelMessage) : ZMQMessage = {
val frames: scala.collection.mutable.ListBuffer[ByteString] = scala.collection.mutable.ListBuffer()
kernelMessage.ids.map((id : Array[Byte]) => frames += ByteString.apply(id) )
frames += "<IDS|MSG>"
frames += kernelMessage.signature
frames += Json.toJson(kernelMessage.header).toString()
frames += Json.toJson(kernelMessage.parentHeader).toString()
frames += Json.toJson(kernelMessage.metadata).toString
frames += kernelMessage.contentString
ZMQMessage(frames : _*)
}
def parseAndHandle[T](json: String, reads: Reads[T], handler: T => Unit) : Unit = {
Json.parse(json).validate[T](reads).fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) =>
logger.error(s"Could not parse JSON, ${json}"),
(content: T) => handler(content)
)
}
def getSessionId = sessionId
def toKernelMessage(message: ExecuteRequest): KernelMessage = {
// construct a kernel message whose content is an ExecuteRequest
val id = java.util.UUID.randomUUID().toString
val header = Header(
id, "spark", sessionId, MessageType.Incoming.ExecuteRequest.toString, "5.0")
KMBuilder().withIds(Seq[Array[Byte]]()).withSignature("").withHeader(header)
.withParentHeader(HeaderBuilder.empty).withContentString(message).build
}
}
Example 15
| Source File: CodeCompleteHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import akka.pattern.ask
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.kernel.protocol.v5.content._
import org.apache.toree.kernel.protocol.v5.kernel.{ActorLoader, Utilities}
import Utilities._
import org.apache.toree.utils.{MessageLogSupport, LogLike}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.Success
class CodeCompleteHandler(actorLoader: ActorLoader)
extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = {
logKernelMessageAction("Generating code completion for", kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CompleteRequest.completeRequestReads,
completeRequest(kernelMessage, _ : CompleteRequest)
)
}
private def completeRequest(km: KernelMessage, cr: CompleteRequest):
Future[(Int, List[String])] = {
val interpreterActor = actorLoader.load(SystemActorType.Interpreter)
val codeCompleteFuture = ask(interpreterActor, cr).mapTo[(Int, List[String])]
codeCompleteFuture.onComplete {
case Success(tuple) =>
val reply = CompleteReplyOk(tuple._2, tuple._1,
cr.cursor_pos, Metadata())
val completeReplyType = MessageType.Outgoing.CompleteReply.toString
logKernelMessageAction("Sending code complete reply for", km)
actorLoader.load(SystemActorType.KernelMessageRelay) !
km.copy(
header = HeaderBuilder.create(completeReplyType),
parentHeader = km.header,
contentString = Json.toJson(reply).toString
)
case _ =>
new Exception("Parse error in CodeCompleteHandler")
}
codeCompleteFuture
}
}
Example 16
| Source File: IsCompleteHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import akka.pattern.ask
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.kernel.protocol.v5.content._
import org.apache.toree.kernel.protocol.v5.kernel.{ActorLoader, Utilities}
import Utilities._
import org.apache.toree.utils.{MessageLogSupport, LogLike}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.Success
class IsCompleteHandler(actorLoader: ActorLoader)
extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = {
logKernelMessageAction("Determining if code is complete for", kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
IsCompleteRequest.isCompleteRequestReads,
isCompleteRequest(kernelMessage, _ : IsCompleteRequest)
)
}
private def isCompleteRequest(km: KernelMessage, cr: IsCompleteRequest):
Future[(String, String)] = {
val interpreterActor = actorLoader.load(SystemActorType.Interpreter)
val codeCompleteFuture = ask(interpreterActor, cr).mapTo[(String, String)]
codeCompleteFuture.onComplete {
case Success(tuple) =>
val reply = IsCompleteReply(tuple._1, tuple._2)
val isCompleteReplyType = MessageType.Outgoing.IsCompleteReply.toString
logKernelMessageAction("Sending is complete reply for", km)
actorLoader.load(SystemActorType.KernelMessageRelay) !
km.copy(
header = HeaderBuilder.create(isCompleteReplyType),
parentHeader = km.header,
contentString = Json.toJson(reply).toString
)
case _ =>
new Exception("Parse error in CodeCompleteHandler")
}
codeCompleteFuture
}
}
Example 17
| Source File: CommMsgHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{KernelCommWriter, CommRegistrar, CommWriter, CommStorage}
import org.apache.toree.global.ExecuteRequestState
import org.apache.toree.kernel.protocol.v5.content.CommMsg
import org.apache.toree.kernel.protocol.v5.kernel.{Utilities, ActorLoader}
import org.apache.toree.kernel.protocol.v5.{KMBuilder, KernelMessage}
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
class CommMsgHandler(
actorLoader: ActorLoader, commRegistrar: CommRegistrar,
commStorage: CommStorage
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Comm Msg for", kernelMessage)
ExecuteRequestState.processIncomingKernelMessage(kernelMessage)
val kmBuilder = KMBuilder().withParent(kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CommMsg.commMsgReads,
handler = handleCommMsg(kmBuilder),
errHandler = handleParseError
)
}
private def handleCommMsg(kmBuilder: KMBuilder)(commMsg: CommMsg) = {
val commId = commMsg.comm_id
val data = commMsg.data
logger.debug(s"Received comm_msg with id '$commId'")
val commWriter = new KernelCommWriter(actorLoader, kmBuilder, commId)
commStorage.getCommIdCallbacks(commId) match {
case None =>
logger.warn(s"Received invalid id for Comm Msg: $commId")
case Some(callbacks) =>
logger.debug(s"Executing msg callbacks for id '$commId'")
// TODO: Should we be checking the return values? Probably not.
callbacks.executeMsgCallbacks(commWriter, commId, data)
.filter(_.isFailure).map(_.failed).foreach(throwable => {
logger.error("Comm msg callback encountered an error!", throwable)
})
}
}
private def handleParseError(invalid: Seq[(JsPath, Seq[ValidationError])]) = {
// TODO: Determine proper response for a parse failure
logger.warn("Parse error for Comm Msg! Not responding!")
}
}
Example 18
| Source File: ShutdownHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{CommRegistrar, CommStorage, KernelCommWriter}
import org.apache.toree.kernel.protocol.v5.content.{ShutdownReply, ShutdownRequest, CommOpen}
import org.apache.toree.kernel.protocol.v5.kernel.{ActorLoader, Utilities}
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.security.KernelSecurityManager
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
class ShutdownHandler(
actorLoader: ActorLoader
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Shutdown request for", kernelMessage)
val shutdownReply = ShutdownReply(false)
val replyHeader = Header(
java.util.UUID.randomUUID.toString,
"",
java.util.UUID.randomUUID.toString,
ShutdownReply.toTypeString,
"")
val kernelResponseMessage = KMBuilder()
.withIds(kernelMessage.ids)
.withSignature("")
.withHeader(replyHeader)
.withParent(kernelMessage)
.withContentString(shutdownReply).build
logger.debug("Attempting graceful shutdown.")
actorLoader.load(SystemActorType.KernelMessageRelay) ! kernelResponseMessage
// Instruct security manager that exit should be allowed
KernelSecurityManager.enableRestrictedExit()
System.exit(0)
}
}
Example 19
| Source File: CommOpenHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{KernelCommWriter, CommStorage, CommRegistrar, CommWriter}
import org.apache.toree.global.ExecuteRequestState
import org.apache.toree.kernel.protocol.v5.content.CommOpen
import org.apache.toree.kernel.protocol.v5.kernel.{Utilities, ActorLoader}
import org.apache.toree.kernel.protocol.v5.{KMBuilder, KernelMessage}
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
class CommOpenHandler(
actorLoader: ActorLoader, commRegistrar: CommRegistrar,
commStorage: CommStorage
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Comm Open for", kernelMessage)
ExecuteRequestState.processIncomingKernelMessage(kernelMessage)
val kmBuilder = KMBuilder().withParent(kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CommOpen.commOpenReads,
handler = handleCommOpen(kmBuilder),
errHandler = handleParseError
)
}
private def handleCommOpen(kmBuilder: KMBuilder)(commOpen: CommOpen) = {
val commId = commOpen.comm_id
val targetName = commOpen.target_name
val data = commOpen.data
logger.debug(
s"Received comm_open for target '$targetName' with id '$commId'")
val commWriter = new KernelCommWriter(actorLoader, kmBuilder, commId)
commStorage.getTargetCallbacks(targetName) match {
case None =>
logger.warn(s"Received invalid target for Comm Open: $targetName")
commWriter.close()
case Some(callbacks) =>
logger.debug(s"Executing open callbacks for id '$commId'")
// TODO: Should we be checking the return values? Probably not.
callbacks.executeOpenCallbacks(commWriter, commId, targetName, data)
.filter(_.isFailure).map(_.failed).foreach(throwable => {
logger.error("Comm open callback encountered an error!", throwable)
})
}
}
private def handleParseError(invalid: Seq[(JsPath, Seq[ValidationError])]) = {
// TODO: Determine proper response for a parse failure
logger.warn("Parse error for Comm Open! Not responding!")
}
}
Example 20
| Source File: CommCloseHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{KernelCommWriter, CommRegistrar, CommWriter, CommStorage}
import org.apache.toree.global.ExecuteRequestState
import org.apache.toree.kernel.protocol.v5.content.CommClose
import org.apache.toree.kernel.protocol.v5.kernel.{Utilities, ActorLoader}
import org.apache.toree.kernel.protocol.v5.{KMBuilder, KernelMessage}
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
class CommCloseHandler(
actorLoader: ActorLoader, commRegistrar: CommRegistrar,
commStorage: CommStorage
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Comm Close for", kernelMessage)
ExecuteRequestState.processIncomingKernelMessage(kernelMessage)
val kmBuilder = KMBuilder().withParent(kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CommClose.commCloseReads,
handler = handleCommClose(kmBuilder),
errHandler = handleParseError
)
}
private def handleCommClose(kmBuilder: KMBuilder)(commClose: CommClose) = {
val commId = commClose.comm_id
val data = commClose.data
logger.debug(s"Received comm_close with id '$commId'")
val commWriter = new KernelCommWriter(actorLoader, kmBuilder, commId)
commStorage.getCommIdCallbacks(commId) match {
case None =>
logger.warn(s"Received invalid id for Comm Close: $commId")
case Some(callbacks) =>
logger.debug(s"Executing close callbacks for id '$commId'")
// TODO: Should we be checking the return values? Probably not.
callbacks.executeCloseCallbacks(commWriter, commId, data)
.filter(_.isFailure).map(_.failed).foreach(throwable => {
logger.error("Comm close callback encountered an error!", throwable)
})
}
}
private def handleParseError(invalid: Seq[(JsPath, Seq[ValidationError])]) = {
// TODO: Determine proper response for a parse failure
logger.warn("Parse error for Comm Close! Not responding!")
}
}
Example 21
| Source File: Utilities.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.kernel
import java.nio.charset.Charset
import akka.util.{ByteString, Timeout}
import org.apache.toree.communication.ZMQMessage
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.utils.LogLike
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json, Reads}
import scala.concurrent.duration._
object Utilities extends LogLike {
//
// NOTE: This is brought in to remove feature warnings regarding the use of
// implicit conversions regarding the following:
//
// 1. ByteStringToString
// 2. ZMQMessageToKernelMessage
//
import scala.language.implicitConversions
implicit val timeout = Timeout(21474835.seconds)
implicit def ByteStringToString(byteString : ByteString) : String = {
new String(byteString.toArray, Charset.forName("UTF-8"))
}
implicit def StringToByteString(string : String) : ByteString = {
ByteString(string.getBytes)
}
implicit def ZMQMessageToKernelMessage(message: ZMQMessage): KernelMessage = {
val delimiterIndex: Int =
message.frames.indexOf(ByteString("<IDS|MSG>".getBytes))
// TODO Handle the case where there is no delimiter
val ids: Seq[Array[Byte]] =
message.frames.take(delimiterIndex).map(
(byteString : ByteString) => { byteString.toArray }
)
val header = Json.parse(message.frames(delimiterIndex + 2)).as[Header]
// TODO: Investigate better solution than setting parentHeader to null for {}
val parentHeader = parseAndHandle(message.frames(delimiterIndex + 3),
ParentHeader.headerReads,
handler = (valid: ParentHeader) => valid,
errHandler = _ => null
)
val metadata = Json.parse(message.frames(delimiterIndex + 4)).as[Metadata]
KMBuilder().withIds(ids.toList)
.withSignature(message.frame(delimiterIndex + 1))
.withHeader(header)
.withParentHeader(parentHeader)
.withMetadata(metadata)
.withContentString(message.frame(delimiterIndex + 5)).build(false)
}
implicit def KernelMessageToZMQMessage(kernelMessage : KernelMessage) : ZMQMessage = {
val frames: scala.collection.mutable.ListBuffer[ByteString] = scala.collection.mutable.ListBuffer()
kernelMessage.ids.map((id : Array[Byte]) => frames += ByteString.apply(id) )
frames += "<IDS|MSG>"
frames += kernelMessage.signature
frames += Json.toJson(kernelMessage.header).toString()
frames += Json.toJson(kernelMessage.parentHeader).toString()
frames += Json.toJson(kernelMessage.metadata).toString
frames += kernelMessage.contentString
ZMQMessage(frames : _*)
}
def parseAndHandle[T, U](json: String, reads: Reads[T],
handler: T => U) : U = {
parseAndHandle(json, reads, handler,
(invalid: Seq[(JsPath, Seq[ValidationError])]) => {
logger.error(s"Could not parse JSON, ${json}")
throw new Throwable(s"Could not parse JSON, ${json}")
}
)
}
def parseAndHandle[T, U](json: String, reads: Reads[T],
handler: T => U,
errHandler: Seq[(JsPath, Seq[ValidationError])] => U) : U = {
Json.parse(json).validate[T](reads).fold(
errHandler,
(content: T) => handler(content)
)
}
}
Example 22
| Source File: SocketConfigSpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.kernel.socket
import com.typesafe.config.ConfigFactory
import org.scalatest.{FunSpec, Matchers}
import org.slf4j.LoggerFactory
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class SocketConfigSpec extends FunSpec with Matchers {
val logger = LoggerFactory.getLogger("jt4")
//logger.error("WOOT!")
private val jsonString: String =
"""
{
"stdin_port": 10000,
"control_port": 10001,
"hb_port": 10002,
"shell_port": 10003,
"iopub_port": 10004,
"ip": "1.2.3.4",
"transport": "tcp",
"signature_scheme": "hmac-sha256",
"key": ""
}
""".stripMargin
val socketConfigJson: JsValue = Json.parse(jsonString)
val socketConfigFromConfig = SocketConfig.fromConfig(ConfigFactory.parseString(jsonString))
val socketConfig = SocketConfig(
10000, 10001, 10002, 10003, 10004, "1.2.3.4", "tcp", "hmac-sha256", ""
)
describe("SocketConfig") {
describe("implicit conversions") {
it("should implicitly convert from valid json to a SocketConfig instance") {
// This is the least safe way to convert as an error is thrown if it fails
socketConfigJson.as[SocketConfig] should be (socketConfig)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newCompleteRequest = socketConfigJson.asOpt[SocketConfig]
newCompleteRequest.get should be (socketConfig)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val CompleteRequestResults = socketConfigJson.validate[SocketConfig]
CompleteRequestResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: SocketConfig) => valid
) should be (socketConfig)
}
it("should implicitly convert from a SocketConfig instance to valid json") {
Json.toJson(socketConfig) should be (socketConfigJson)
}
}
describe("#toConfig") {
it("should implicitly convert from valid json to a SocketConfig instance") {
// This is the least safe way to convert as an error is thrown if it fails
socketConfigFromConfig should be (socketConfig)
}
it("should convert json file to SocketConfig object") {
socketConfigFromConfig.stdin_port should be (10000)
}
}
}
}
Example 23
| Source File: Domain.scala From play-swagger with Apache License 2.0 | 5 votes |
|
package com.iheart.playSwagger
import play.api.libs.json.{ JsObject, JsPath, JsValue, Reads }
import play.twirl.api.TemplateMagic.Default
object Domain {
type Path = String
type Method = String
final case class Definition(
name: String,
properties: Seq[SwaggerParameter],
description: Option[String] = None)
sealed trait SwaggerParameter {
def name: String
def required: Boolean
def default: Option[JsValue]
def update(required: Boolean, default: Option[JsValue]): SwaggerParameter
}
final case class GenSwaggerParameter(
name: String,
referenceType: Option[String] = None,
`type`: Option[String] = None,
format: Option[String] = None,
required: Boolean = true,
default: Option[JsValue] = None,
example: Option[JsValue] = None,
items: Option[SwaggerParameter] = None,
enum: Option[Seq[String]] = None) extends SwaggerParameter {
def update(_required: Boolean, _default: Option[JsValue]) =
copy(required = _required, default = _default)
}
final case class CustomSwaggerParameter(
name: String,
specAsParameter: List[JsObject],
specAsProperty: Option[JsObject],
required: Boolean = true,
default: Option[JsValue] = None) extends SwaggerParameter {
def update(_required: Boolean, _default: Option[JsValue]) =
copy(required = _required, default = _default)
}
type CustomMappings = List[CustomTypeMapping]
case class CustomTypeMapping(
`type`: String,
specAsParameter: List[JsObject] = Nil,
specAsProperty: Option[JsObject] = None,
required: Boolean = true)
object CustomTypeMapping {
import play.api.libs.functional.syntax._
implicit val csmFormat: Reads[CustomTypeMapping] = (
(JsPath \ 'type).read[String] and
(JsPath \ 'specAsParameter).read[List[JsObject]] and
(JsPath \ 'specAsProperty).readNullable[JsObject] and
((JsPath \ 'required).read[Boolean] orElse Reads.pure(true)))(CustomTypeMapping.apply _)
}
}
Example 24
| Source File: SignedSetAssetScriptRequest.scala From Waves with MIT License | 5 votes |
|
package com.wavesplatform.api.http.requests
import com.wavesplatform.account.PublicKey
import com.wavesplatform.lang.ValidationError
import com.wavesplatform.lang.script.Script
import com.wavesplatform.transaction.Asset.IssuedAsset
import com.wavesplatform.transaction.Proofs
import com.wavesplatform.transaction.assets.SetAssetScriptTransaction
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Reads}
object SignedSetAssetScriptRequest {
implicit val signedSetAssetScriptRequestReads: Reads[SignedSetAssetScriptRequest] = (
(JsPath \ "version").readNullable[Byte] and
(JsPath \ "senderPublicKey").read[String] and
(JsPath \ "assetId").read[IssuedAsset] and
(JsPath \ "script").readNullable[String] and
(JsPath \ "fee").read[Long] and
(JsPath \ "timestamp").read[Long] and
(JsPath \ "proofs").read[Proofs]
)(SignedSetAssetScriptRequest.apply _)
}
case class SignedSetAssetScriptRequest(
version: Option[Byte],
senderPublicKey: String,
assetId: IssuedAsset,
script: Option[String],
fee: Long,
timestamp: Long,
proofs: Proofs
) {
def toTx: Either[ValidationError, SetAssetScriptTransaction] =
for {
_sender <- PublicKey.fromBase58String(senderPublicKey)
_script <- script match {
case None | Some("") => Right(None)
case Some(s) => Script.fromBase64String(s).map(Some(_))
}
t <- SetAssetScriptTransaction.create(version.getOrElse(1.toByte), _sender, assetId, _script, fee, timestamp, proofs)
} yield t
}
Example 25
| Source File: SignedReissueV2Request.scala From Waves with MIT License | 5 votes |
|
package com.wavesplatform.api.http.requests
import cats.implicits._
import com.wavesplatform.account.{AddressScheme, PublicKey}
import com.wavesplatform.lang.ValidationError
import com.wavesplatform.transaction.Proofs
import com.wavesplatform.transaction.assets.ReissueTransaction
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Reads}
case class SignedReissueV2Request(
senderPublicKey: String,
assetId: String,
quantity: Long,
reissuable: Boolean,
fee: Long,
timestamp: Long,
proofs: List[String]
) {
def toTx: Either[ValidationError, ReissueTransaction] =
for {
_sender <- PublicKey.fromBase58String(senderPublicKey)
chainId = AddressScheme.current.chainId
_proofBytes <- proofs.traverse(s => parseBase58(s, "invalid proof", Proofs.MaxProofStringSize))
_proofs <- Proofs.create(_proofBytes)
_assetId <- parseBase58ToIssuedAsset(assetId)
_t <- ReissueTransaction.create(2.toByte, _sender, _assetId, quantity, reissuable, fee, timestamp, _proofs)
} yield _t
}
object SignedReissueV2Request {
implicit val assetReissueRequestReads: Reads[SignedReissueV2Request] = (
(JsPath \ "senderPublicKey").read[String] and
(JsPath \ "assetId").read[String] and
(JsPath \ "quantity").read[Long] and
(JsPath \ "reissuable").read[Boolean] and
(JsPath \ "fee").read[Long] and
(JsPath \ "timestamp").read[Long] and
(JsPath \ "proofs").read[List[ProofStr]]
)(SignedReissueV2Request.apply _)
}
Example 26
| Source File: SignedExchangeRequestV2.scala From Waves with MIT License | 5 votes |
|
package com.wavesplatform.api.http.requests
import cats.implicits._
import com.wavesplatform.lang.ValidationError
import com.wavesplatform.transaction.Proofs
import com.wavesplatform.transaction.assets.exchange.{ExchangeTransaction, Order}
import play.api.libs.functional.syntax._
import play.api.libs.json.{Format, JsPath, Reads}
object SignedExchangeRequestV2 {
implicit val orderFormat: Format[Order] = com.wavesplatform.transaction.assets.exchange.OrderJson.orderFormat
implicit val signedExchangeRequestReads: Reads[SignedExchangeRequestV2] = (
(JsPath \ "senderPublicKey").read[String] and
(JsPath \ "order1").read[Order] and
(JsPath \ "order2").read[Order] and
(JsPath \ "price").read[Long] and
(JsPath \ "amount").read[Long] and
(JsPath \ "fee").read[Long] and
(JsPath \ "buyMatcherFee").read[Long] and
(JsPath \ "sellMatcherFee").read[Long] and
(JsPath \ "timestamp").read[Long] and
(JsPath \ "version").read[Byte] and
(JsPath \ "proofs").read[List[ProofStr]]
)(SignedExchangeRequestV2.apply _)
}
case class SignedExchangeRequestV2(
senderPublicKey: String,
order1: Order,
order2: Order,
price: Long,
amount: Long,
fee: Long,
buyMatcherFee: Long,
sellMatcherFee: Long,
timestamp: Long,
version: Byte,
proofs: List[String]
) {
def toTx: Either[ValidationError, ExchangeTransaction] =
for {
_proofBytes <- proofs.traverse(s => parseBase58(s, "invalid proof", Proofs.MaxProofStringSize))
_proofs <- Proofs.create(_proofBytes)
_t <- ExchangeTransaction.create(2.toByte, order1, order2, amount, price, buyMatcherFee, sellMatcherFee, fee, timestamp, _proofs)
} yield _t
}
Example 27
| Source File: play.scala From caliban with Apache License 2.0 | 5 votes |
|
package caliban.interop.play
import caliban.introspection.adt.__Type
import caliban.schema.Step.QueryStep
import caliban.schema.Types.makeScalar
import caliban.schema.{ ArgBuilder, PureStep, Schema, Step }
import caliban.{ InputValue, ResponseValue }
import play.api.libs.json.{ JsPath, JsValue, Json, JsonValidationError, Reads, Writes }
import zio.ZIO
import zio.query.ZQuery
private[caliban] trait IsPlayJsonReads[F[_]]
private[caliban] object IsPlayJsonReads {
implicit val isPlayJsonReads: IsPlayJsonReads[Reads] = null
}
object json {
implicit val jsonSchema: Schema[Any, JsValue] = new Schema[Any, JsValue] {
private def parse(value: JsValue) =
implicitly[Reads[ResponseValue]]
.reads(value)
.asEither
.left
.map(parsingException)
override def toType(isInput: Boolean, isSubscription: Boolean): __Type = makeScalar("Json")
override def resolve(value: JsValue): Step[Any] =
QueryStep(ZQuery.fromEffect(ZIO.fromEither(parse(value))).map(PureStep))
}
implicit val jsonArgBuilder: ArgBuilder[JsValue] = (input: InputValue) => Right(Json.toJson(input))
private[caliban] def parsingException(
errs: scala.collection.Seq[(JsPath, scala.collection.Seq[JsonValidationError])]
) =
new Throwable(s"Couldn't decode json: $errs")
}
Example 28
| Source File: BackendConnector.scala From nisp-frontend with Apache License 2.0 | 5 votes |
|
package uk.gov.hmrc.nisp.connectors
import play.api.data.validation.ValidationError
import play.api.libs.json.{Format, JsObject, JsPath}
import uk.gov.hmrc.http.cache.client.SessionCache
import uk.gov.hmrc.nisp.models.enums.APIType._
import uk.gov.hmrc.nisp.services.MetricsService
import uk.gov.hmrc.nisp.utils.JsonDepersonaliser
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.{Failure, Success}
import uk.gov.hmrc.http.{ HeaderCarrier, HttpGet, HttpResponse }
trait BackendConnector {
def http: HttpGet
def serviceUrl: String
def sessionCache: SessionCache
val metricsService: MetricsService
protected def retrieveFromCache[A](api: APIType, url: String)(implicit hc: HeaderCarrier, formats: Format[A]): Future[A] = {
val keystoreTimerContext = metricsService.keystoreReadTimer.time()
val sessionCacheF = sessionCache.fetchAndGetEntry[A](api.toString)
sessionCacheF.onFailure {
case _ => metricsService.keystoreReadFailed.inc()
}
sessionCacheF.flatMap { keystoreResult =>
keystoreTimerContext.stop()
keystoreResult match {
case Some(data) =>
metricsService.keystoreHitCounter.inc()
Future.successful(data)
case None =>
metricsService.keystoreMissCounter.inc()
connectToMicroservice[A](url, api) map {
data: A => cacheResult(data, api.toString)
}
}
}
}
private def connectToMicroservice[A](urlToRead: String, apiType: APIType)(implicit hc: HeaderCarrier, formats: Format[A]): Future[A] = {
val timerContext = metricsService.startTimer(apiType)
val httpResponseF = http.GET[HttpResponse](urlToRead)
httpResponseF onSuccess {
case _ => timerContext.stop()
}
httpResponseF onFailure {
case _ => metricsService.incrementFailedCounter(apiType)
}
httpResponseF.map {
httpResponse => httpResponse.json.validate[A].fold(
errs => {
val json = JsonDepersonaliser.depersonalise(httpResponse.json) match {
case Success(s) => s"Depersonalised JSON\n$s"
case Failure(e) => s"JSON could not be depersonalised\n${e.toString()}"
}
throw new JsonValidationException(s"Unable to deserialise $apiType: ${formatJsonErrors(errs)}\n$json")
},
valid => valid
)
}
}
private def cacheResult[A](a:A,name: String)(implicit hc: HeaderCarrier, formats: Format[A]): A = {
val timerContext = metricsService.keystoreWriteTimer.time()
val cacheF = sessionCache.cache[A](name, a)
cacheF.onSuccess {
case _ => timerContext.stop()
}
cacheF.onFailure {
case _ => metricsService.keystoreWriteFailed.inc()
}
a
}
private def formatJsonErrors(errors: Seq[(JsPath, Seq[ValidationError])]): String = {
errors.map(p => p._1 + " - " + p._2.map(e => removeJson(e.message)).mkString(",")).mkString(" | ")
}
private def removeJson(message: String): String = {
message.indexOf("{") match {
case i if i != -1 => message.substring(0, i - 1) + " [JSON removed]"
case _ => message
}
}
private[connectors] class JsonValidationException(message: String) extends Exception(message)
}
Example 29
| Source File: CodeCompleteHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import akka.pattern.ask
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.kernel.protocol.v5.content._
import org.apache.toree.kernel.protocol.v5.kernel.{ActorLoader, Utilities}
import Utilities._
import org.apache.toree.utils.{MessageLogSupport, LogLike}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.Success
class CodeCompleteHandler(actorLoader: ActorLoader)
extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = {
logKernelMessageAction("Generating code completion for", kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CompleteRequest.completeRequestReads,
completeRequest(kernelMessage, _ : CompleteRequest)
)
}
private def completeRequest(km: KernelMessage, cr: CompleteRequest):
Future[(Int, List[String])] = {
val interpreterActor = actorLoader.load(SystemActorType.Interpreter)
val codeCompleteFuture = ask(interpreterActor, cr).mapTo[(Int, List[String])]
codeCompleteFuture.onComplete {
case Success(tuple) =>
val reply = CompleteReplyOk(tuple._2, tuple._1,
cr.cursor_pos, Metadata())
val completeReplyType = MessageType.Outgoing.CompleteReply.toString
logKernelMessageAction("Sending code complete reply for", km)
actorLoader.load(SystemActorType.KernelMessageRelay) !
km.copy(
header = HeaderBuilder.create(completeReplyType),
parentHeader = km.header,
contentString = Json.toJson(reply).toString
)
case _ =>
new Exception("Parse error in CodeCompleteHandler")
}
codeCompleteFuture
}
}
Example 30
| Source File: Liability.scala From vat-api with Apache License 2.0 | 5 votes |
|
package v1.models.response.liabilities
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Json, OWrites, Reads}
import utils.NestedJsonReads
import v1.models.response.common.TaxPeriod
case class Liability(taxPeriod: Option[TaxPeriod],
`type`: String,
originalAmount: BigDecimal,
outstandingAmount: Option[BigDecimal],
due: Option[String])
object Liability extends NestedJsonReads {
implicit val writes: OWrites[Liability] = Json.writes[Liability]
implicit val reads: Reads[Liability] = (
TaxPeriod.reads and
(JsPath \ "chargeType").read[String] and
(JsPath \ "originalAmount").read[BigDecimal] and
(JsPath \ "outstandingAmount").readNullable[BigDecimal] and
(JsPath \ "items" \\ "dueDate").readNestedNullable[String]
)(Liability.apply _)
}
Example 31
| Source File: Obligation.scala From vat-api with Apache License 2.0 | 5 votes |
|
package v1.models.response.obligations
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Json, OWrites, Reads}
case class Obligation(periodKey: String,
start: String,
end: String,
due: String,
status: String,
received: Option[String])
object Obligation {
implicit val writes: OWrites[Obligation] = Json.writes[Obligation]
implicit val reads: Reads[Obligation] = (
(JsPath \ "periodKey").read[String] and
(JsPath \ "inboundCorrespondenceFromDate").read[String] and
(JsPath \ "inboundCorrespondenceToDate").read[String] and
(JsPath \ "inboundCorrespondenceDueDate").read[String] and
(JsPath \ "status").read[String] and
(JsPath \ "inboundCorrespondenceDateReceived").readNullable[String]
)(Obligation.apply _)
}
Example 32
| Source File: ViewReturnResponse.scala From vat-api with Apache License 2.0 | 5 votes |
|
package v1.models.response.viewReturn
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Json, OWrites, Reads}
case class ViewReturnResponse(periodKey: String,
vatDueSales: BigDecimal,
vatDueAcquisitions: BigDecimal,
totalVatDue: BigDecimal,
vatReclaimedCurrPeriod: BigDecimal,
netVatDue: BigDecimal,
totalValueSalesExVAT: BigDecimal,
totalValuePurchasesExVAT: BigDecimal,
totalValueGoodsSuppliedExVAT: BigDecimal,
totalAcquisitionsExVAT: BigDecimal)
object ViewReturnResponse {
implicit val writes: OWrites[ViewReturnResponse] = Json.writes[ViewReturnResponse]
implicit val reads: Reads[ViewReturnResponse] = (
(JsPath \ "periodKey").read[String] and
(JsPath \ "vatDueSales").read[BigDecimal] and
(JsPath \ "vatDueAcquisitions").read[BigDecimal] and
(JsPath \ "vatDueTotal").read[BigDecimal] and
(JsPath \ "vatReclaimedCurrPeriod"). read[BigDecimal] and
(JsPath \ "vatDueNet").read[BigDecimal] and
(JsPath \ "totalValueSalesExVAT").read[BigDecimal] and
(JsPath \ "totalValuePurchasesExVAT").read[BigDecimal] and
(JsPath \ "totalValueGoodsSuppliedExVAT").read[BigDecimal] and
(JsPath \ "totalAllAcquisitionsExVAT").read[BigDecimal]
)(ViewReturnResponse.apply _)
}
Example 33
| Source File: ResourcesSpec.scala From vat-api with Apache License 2.0 | 5 votes |
|
package uk.gov.hmrc.vatapi.resources
import play.api.libs.json.{JsPath, JsonValidationError}
import uk.gov.hmrc.vatapi.UnitSpec
import uk.gov.hmrc.vatapi.models.{ErrorCode, Errors}
class ResourcesSpec extends UnitSpec {
"Errors.badRequest" should {
"translate Json string validation error to the appropriate error code" in {
val errors = Seq((JsPath \ "a", Seq(JsonValidationError("error.expected.jsstring"))))
Errors.badRequest(errors).errors.head.code shouldBe ErrorCode.INVALID_STRING_VALUE.toString
}
"translate Json numeric validation error to the appropriate error code" in {
val errors = Seq((JsPath \ "a", Seq(JsonValidationError("error.expected.numberformatexception"))))
Errors.badRequest(errors).errors.head.code shouldBe ErrorCode.INVALID_NUMERIC_VALUE.toString
}
}
}
Example 34
| Source File: ResultMessage.scala From Aton with GNU General Public License v3.0 | 5 votes |
|
package model.json
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
case class ResultMessage(
result: String,
extras: Seq[ResultMessageExtra]
){
def this(result: String) = this(result, Seq.empty)
}
object ResultMessage {
val inputWasNotAJson: ResultMessage = new ResultMessage("Input was not a JSON")
def wrongJsonFormat(errors: Seq[(JsPath, Seq[ValidationError])]): ResultMessage = {
val mapped = errors.map(singleError=>{
val error = singleError._2.map(y => y.message match {
case "error.path.missing" => "Missing"
case "error.expected.jsnumber" => "Number expected"
case otherError => otherError
}).mkString(", ")
ResultMessageExtra(singleError._1.toString().drop(1),error)
})
ResultMessage("Wrong json format", mapped)
}
}
Example 35
| Source File: PlayDefinitions.scala From circe-benchmarks with Apache License 2.0 | 5 votes |
|
package io.circe.benchmarks
import org.openjdk.jmh.annotations._
import play.api.libs.functional.syntax._
import play.api.libs.json.{ Format, JsPath, JsValue, Json, Writes }
trait PlayFooInstances {
implicit val playFormatFoo: Format[Foo] = (
(JsPath \ "s")
.format[String]
.and((JsPath \ "d").format[Double])
.and((JsPath \ "i").format[Int])
.and((JsPath \ "l").format[Long])
.and((JsPath \ "bs").format[List[Boolean]])
)(Foo.apply, unlift(Foo.unapply))
}
trait PlayData { self: ExampleData =>
@inline def encodeP[A](a: A)(implicit encode: Writes[A]): JsValue = encode.writes(a)
val foosP: JsValue = encodeP(foos)
val intsP: JsValue = encodeP(ints)
}
trait PlayWriting { self: ExampleData =>
@Benchmark
def writeFoosPlay: String = Json.stringify(encodeP(foos))
@Benchmark
def writeIntsPlay: String = Json.stringify(encodeP(ints))
}
trait PlayReading { self: ExampleData =>
@Benchmark
def readFoosPlay: Map[String, Foo] = Json.parse(foosJson).as[Map[String, Foo]]
@Benchmark
def readIntsPlay: List[Int] = Json.parse(intsJson).as[List[Int]]
}
trait PlayEncoding { self: ExampleData =>
@Benchmark
def encodeFoosPlay: JsValue = encodeP(foos)
@Benchmark
def encodeIntsPlay: JsValue = encodeP(ints)
}
trait PlayDecoding { self: ExampleData =>
@Benchmark
def decodeFoosPlay: Map[String, Foo] = foosP.as[Map[String, Foo]]
@Benchmark
def decodeIntsPlay: List[Int] = intsP.as[List[Int]]
}
trait PlayPrinting { self: ExampleData =>
@Benchmark
def printFoosPlay: String = Json.stringify(foosP)
@Benchmark
def printIntsPlay: String = Json.stringify(intsP)
}
trait PlayParsing { self: ExampleData =>
@Benchmark
def parseFoosPlay: JsValue = Json.parse(foosJson)
@Benchmark
def parseIntsPlay: JsValue = Json.parse(intsJson)
}
Example 36
| Source File: TokenInfo.scala From play-zhewbacca with MIT License | 5 votes |
|
package org.zalando.zhewbacca
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Reads}
case class TokenInfo(
accessToken: String,
scope: Scope,
tokenType: String,
userUid: String,
clientId: Option[String] = None,
realm: String = "unknown")
object TokenInfo {
implicit val tokenInfoReads: Reads[TokenInfo] = (
(JsPath \ "access_token").read[String] and
(JsPath \ "scope").read[Seq[String]].map(names => Scope(Set(names: _*))) and
(JsPath \ "token_type").read[String] and
(JsPath \ "uid").read[String] and
(JsPath \ "client_id").readNullable[String] and
(JsPath \ "realm").read[String])(TokenInfo.apply _)
}
Example 37
| Source File: JsonEntitiesFromCodecs.scala From endpoints4s with MIT License | 5 votes |
|
package endpoints4s.algebra.playjson
import endpoints4s.{Codec, Invalid, Valid, Validated}
import play.api.libs.json.{Format, JsPath, Json, JsonValidationError}
import scala.util.{Failure, Success, Try}
trait JsonEntitiesFromCodecs extends endpoints4s.algebra.JsonEntitiesFromCodecs {
//#type-carrier
type JsonCodec[A] = Format[A]
//#type-carrier
def stringCodec[A: Format]: Codec[String, A] =
new Codec[String, A] {
def decode(from: String): Validated[A] =
(Try(Json.parse(from)) match {
case Failure(_) => Left(Invalid("Unable to parse entity as JSON"))
case Success(a) => Right(a)
}).flatMap { json =>
def showErrors(
errors: collection.Seq[
(JsPath, collection.Seq[JsonValidationError])
]
): Invalid =
Invalid(
(
for {
(path, pathErrors) <- errors.iterator
error <- pathErrors
} yield s"${error.message} for ${path.toJsonString}"
).toSeq
)
Json
.fromJson[A](json)
.asEither
.left
.map(showErrors)
.map(Valid(_))
}.merge
def encode(from: A): String = Json.stringify(Json.toJson(from))
}
}
Example 38
| Source File: HeaderSpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5
import org.scalatest.{Matchers, FunSpec}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json, JsValue}
class HeaderSpec extends FunSpec with Matchers {
val headerJson: JsValue = Json.parse("""
{
"msg_id": "<UUID>",
"username": "<STRING>",
"session": "<UUID>",
"msg_type": "<STRING>",
"version": "<FLOAT>"
}
""")
val header: Header = Header(
"<UUID>", "<STRING>", "<UUID>", "<STRING>", "<FLOAT>"
)
describe("Header") {
describe("when null") {
it("should implicitly convert to empty json") {
val header: Header = null
Json.toJson(header).toString() should be ("{}")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a header instance") {
// This is the least safe way to convert as an error is thrown if it fails
headerJson.as[Header] should be (header)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newHeader = headerJson.asOpt[Header]
newHeader.get should be (header)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val headerResults = headerJson.validate[Header]
headerResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: Header) => valid
) should be (header)
}
it("should implicitly convert from a header instance to valid json") {
Json.toJson(header) should be (headerJson)
}
}
}
}
Example 39
| Source File: ConnectReplySpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.content
import org.scalatest.{FunSpec, Matchers}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class ConnectReplySpec extends FunSpec with Matchers {
val connectReplyJson: JsValue = Json.parse("""
{
"shell_port": 11111,
"iopub_port": 22222,
"stdin_port": 33333,
"hb_port": 44444
}
""")
val connectReply: ConnectReply = ConnectReply(11111,22222,33333,44444)
describe("ConnectReply") {
describe("#toTypeString") {
it("should return correct type") {
ConnectReply.toTypeString should be ("connect_reply")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a ConnectReply instance") {
// This is the least safe way to convert as an error is thrown if it fails
connectReplyJson.as[ConnectReply] should be (connectReply)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newConnectReply = connectReplyJson.asOpt[ConnectReply]
newConnectReply.get should be (connectReply)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val ConnectReplyResults = connectReplyJson.validate[ConnectReply]
ConnectReplyResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: ConnectReply) => valid
) should be (connectReply)
}
it("should implicitly convert from a ConnectReply instance to valid json") {
Json.toJson(connectReply) should be (connectReplyJson)
}
}
}
}
Example 40
| Source File: CompleteReplySpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.content
import org.scalatest.{Matchers, FunSpec}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class CompleteReplySpec extends FunSpec with Matchers {
val completeReplyJson: JsValue = Json.parse("""
{
"matches": [],
"cursor_start": 1,
"cursor_end": 5,
"metadata": {},
"status": "<STRING>"
}
""")
val completeReply: CompleteReply = CompleteReply(
List(), 1, 5, Map(), "<STRING>", None, None, None
)
describe("CompleteReply") {
describe("#toTypeString") {
it("should return correct type") {
CompleteReply.toTypeString should be ("complete_reply")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a CompleteReply instance") {
// This is the least safe way to convert as an error is thrown if it fails
completeReplyJson.as[CompleteReply] should be (completeReply)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newCompleteReply = completeReplyJson.asOpt[CompleteReply]
newCompleteReply.get should be (completeReply)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val CompleteReplyResults = completeReplyJson.validate[CompleteReply]
CompleteReplyResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: CompleteReply) => valid
) should be (completeReply)
}
it("should implicitly convert from a CompleteReply instance to valid json") {
Json.toJson(completeReply) should be (completeReplyJson)
}
}
}
}
Example 41
| Source File: KernelStatusSpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.content
import org.scalatest.{FunSpec, Matchers}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class KernelStatusSpec extends FunSpec with Matchers {
val kernelStatusJson: JsValue = Json.parse("""
{
"execution_state": "<STRING>"
}
""")
val kernelStatus: KernelStatus = KernelStatus("<STRING>")
describe("KernelStatus") {
describe("#toTypeString") {
it("should return correct type") {
KernelStatus.toTypeString should be ("status")
}
}
describe("implicit conversions") {
it("should implicitly convert from valid json to a kernelStatus instance") {
// This is the least safe way to convert as an error is thrown if it fails
kernelStatusJson.as[KernelStatus] should be (kernelStatus)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newKernelStatus = kernelStatusJson.asOpt[KernelStatus]
newKernelStatus.get should be (kernelStatus)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val kernelStatusResults = kernelStatusJson.validate[KernelStatus]
kernelStatusResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: KernelStatus) => valid
) should be (kernelStatus)
}
it("should implicitly convert from a kernelStatus instance to valid json") {
Json.toJson(kernelStatus) should be (kernelStatusJson)
}
}
}
}
Example 42
| Source File: Utilities.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.client
import java.nio.charset.Charset
import akka.util.{ByteString, Timeout}
import org.apache.toree.communication.ZMQMessage
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.kernel.protocol.v5.content.ExecuteRequest
import org.apache.toree.utils.LogLike
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json, Reads}
import scala.concurrent.duration._
object Utilities extends LogLike {
//
// NOTE: This is brought in to remove feature warnings regarding the use of
// implicit conversions regarding the following:
//
// 1. ByteStringToString
// 2. ZMQMessageToKernelMessage
//
import scala.language.implicitConversions
private val sessionId: UUID = java.util.UUID.randomUUID().toString
implicit val timeout = Timeout(21474835.seconds) // Maximum delay
implicit def ByteStringToString(byteString : ByteString) : String = {
new String(byteString.toArray, Charset.forName("UTF-8"))
}
implicit def StringToByteString(string : String) : ByteString = {
ByteString(string.getBytes)
}
implicit def ZMQMessageToKernelMessage(message: ZMQMessage): KernelMessage = {
val delimiterIndex: Int =
message.frames.indexOf(ByteString("<IDS|MSG>".getBytes))
// TODO Handle the case where there is no delimiter
val ids: Seq[Array[Byte]] =
message.frames.take(delimiterIndex).map(
(byteString : ByteString) => { byteString.toArray }
)
val header = Json.parse(message.frames(delimiterIndex + 2)).as[Header]
val parentHeader = Json.parse(message.frames(delimiterIndex + 3)).validate[ParentHeader].fold[ParentHeader](
// TODO: Investigate better solution than setting parentHeader to null for {}
(invalid: Seq[(JsPath, Seq[ValidationError])]) => null, //HeaderBuilder.empty,
(valid: ParentHeader) => valid
)
val metadata = Json.parse(message.frames(delimiterIndex + 4)).as[Metadata]
KMBuilder().withIds(ids.toList)
.withSignature(message.frame(delimiterIndex + 1))
.withHeader(header)
.withParentHeader(parentHeader)
.withMetadata(metadata)
.withContentString(message.frame(delimiterIndex + 5)).build(false)
}
implicit def KernelMessageToZMQMessage(kernelMessage : KernelMessage) : ZMQMessage = {
val frames: scala.collection.mutable.ListBuffer[ByteString] = scala.collection.mutable.ListBuffer()
kernelMessage.ids.map((id : Array[Byte]) => frames += ByteString.apply(id) )
frames += "<IDS|MSG>"
frames += kernelMessage.signature
frames += Json.toJson(kernelMessage.header).toString()
frames += Json.toJson(kernelMessage.parentHeader).toString()
frames += Json.toJson(kernelMessage.metadata).toString
frames += kernelMessage.contentString
ZMQMessage(frames : _*)
}
def parseAndHandle[T](json: String, reads: Reads[T], handler: T => Unit) : Unit = {
Json.parse(json).validate[T](reads).fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) =>
logger.error(s"Could not parse JSON, ${json}"),
(content: T) => handler(content)
)
}
def getSessionId = sessionId
def toKernelMessage(message: ExecuteRequest): KernelMessage = {
// construct a kernel message whose content is an ExecuteRequest
val id = java.util.UUID.randomUUID().toString
val header = Header(
id, "spark", sessionId, MessageType.Incoming.ExecuteRequest.toString, "5.0")
KMBuilder().withIds(Seq[Array[Byte]]()).withSignature("").withHeader(header)
.withParentHeader(HeaderBuilder.empty).withContentString(message).build
}
}
Example 43
| Source File: Resources.scala From cluster-broccoli with Apache License 2.0 | 5 votes |
|
package de.frosner.broccoli.nomad.models
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, OFormat}
import shapeless.tag
import shapeless.tag.@@
import squants.information.{Information, Megabytes}
import squants.time.{Frequency, Megahertz}
final case class Resources(cpu: Frequency @@ Resources.CPU, memory: Information @@ Resources.Memory)
object Resources {
sealed trait CPU
sealed trait Memory
implicit val resourcesFormat: OFormat[Resources] = (
(JsPath \ "CPU")
.format[Double]
.inmap[Frequency @@ CPU](mhz => tag[CPU](Megahertz(mhz)), _.toMegahertz)
and
(JsPath \ "MemoryMB")
.format[Double]
.inmap[Information @@ Memory](mb => tag[Memory](Megabytes(mb)), _.toMegabytes)
)(Resources.apply, unlift(Resources.unapply))
}
Example 44
| Source File: IsCompleteHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import akka.pattern.ask
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.kernel.protocol.v5.content._
import org.apache.toree.kernel.protocol.v5.kernel.{ActorLoader, Utilities}
import Utilities._
import org.apache.toree.utils.{MessageLogSupport, LogLike}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.Success
class IsCompleteHandler(actorLoader: ActorLoader)
extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = {
logKernelMessageAction("Determining if code is complete for", kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
IsCompleteRequest.isCompleteRequestReads,
isCompleteRequest(kernelMessage, _ : IsCompleteRequest)
)
}
private def isCompleteRequest(km: KernelMessage, cr: IsCompleteRequest):
Future[(String, String)] = {
val interpreterActor = actorLoader.load(SystemActorType.Interpreter)
val codeCompleteFuture = ask(interpreterActor, cr).mapTo[(String, String)]
codeCompleteFuture.onComplete {
case Success(tuple) =>
val reply = IsCompleteReply(tuple._1, tuple._2)
val isCompleteReplyType = MessageType.Outgoing.IsCompleteReply.toString
logKernelMessageAction("Sending is complete reply for", km)
actorLoader.load(SystemActorType.KernelMessageRelay) !
km.copy(
header = HeaderBuilder.create(isCompleteReplyType),
parentHeader = km.header,
contentString = Json.toJson(reply).toString
)
case _ =>
new Exception("Parse error in CodeCompleteHandler")
}
codeCompleteFuture
}
}
Example 45
| Source File: CommMsgHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{KernelCommWriter, CommRegistrar, CommWriter, CommStorage}
import org.apache.toree.global.ExecuteRequestState
import org.apache.toree.kernel.protocol.v5.content.CommMsg
import org.apache.toree.kernel.protocol.v5.kernel.{Utilities, ActorLoader}
import org.apache.toree.kernel.protocol.v5.{KMBuilder, KernelMessage}
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
class CommMsgHandler(
actorLoader: ActorLoader, commRegistrar: CommRegistrar,
commStorage: CommStorage
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Comm Msg for", kernelMessage)
ExecuteRequestState.processIncomingKernelMessage(kernelMessage)
val kmBuilder = KMBuilder().withParent(kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CommMsg.commMsgReads,
handler = handleCommMsg(kmBuilder),
errHandler = handleParseError
)
}
private def handleCommMsg(kmBuilder: KMBuilder)(commMsg: CommMsg) = {
val commId = commMsg.comm_id
val data = commMsg.data
logger.debug(s"Received comm_msg with id '$commId'")
val commWriter = new KernelCommWriter(actorLoader, kmBuilder, commId)
commStorage.getCommIdCallbacks(commId) match {
case None =>
logger.warn(s"Received invalid id for Comm Msg: $commId")
case Some(callbacks) =>
logger.debug(s"Executing msg callbacks for id '$commId'")
// TODO: Should we be checking the return values? Probably not.
callbacks.executeMsgCallbacks(commWriter, commId, data)
.filter(_.isFailure).map(_.failed).foreach(throwable => {
logger.error("Comm msg callback encountered an error!", throwable)
})
}
}
private def handleParseError(invalid: Seq[(JsPath, Seq[ValidationError])]) = {
// TODO: Determine proper response for a parse failure
logger.warn("Parse error for Comm Msg! Not responding!")
}
}
Example 46
| Source File: ShutdownHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{CommRegistrar, CommStorage, KernelCommWriter}
import org.apache.toree.kernel.protocol.v5.content.{ShutdownReply, ShutdownRequest, CommOpen}
import org.apache.toree.kernel.protocol.v5.kernel.{ActorLoader, Utilities}
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.security.KernelSecurityManager
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
class ShutdownHandler(
actorLoader: ActorLoader
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Shutdown request for", kernelMessage)
val kernelInfo = SparkKernelInfo
val shutdownReply = ShutdownReply(false)
val replyHeader = Header(
java.util.UUID.randomUUID.toString,
"",
java.util.UUID.randomUUID.toString,
ShutdownReply.toTypeString,
kernelInfo.protocolVersion)
val kernelResponseMessage = KMBuilder()
.withIds(kernelMessage.ids)
.withSignature("")
.withHeader(replyHeader)
.withParent(kernelMessage)
.withContentString(shutdownReply).build
logger.debug("Attempting graceful shutdown.")
actorLoader.load(SystemActorType.KernelMessageRelay) ! kernelResponseMessage
// Instruct security manager that exit should be allowed
KernelSecurityManager.enableRestrictedExit()
System.exit(0)
}
}
Example 47
| Source File: CommOpenHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{KernelCommWriter, CommStorage, CommRegistrar, CommWriter}
import org.apache.toree.global.ExecuteRequestState
import org.apache.toree.kernel.protocol.v5.content.CommOpen
import org.apache.toree.kernel.protocol.v5.kernel.{Utilities, ActorLoader}
import org.apache.toree.kernel.protocol.v5.{KMBuilder, KernelMessage}
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
class CommOpenHandler(
actorLoader: ActorLoader, commRegistrar: CommRegistrar,
commStorage: CommStorage
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Comm Open for", kernelMessage)
ExecuteRequestState.processIncomingKernelMessage(kernelMessage)
val kmBuilder = KMBuilder().withParent(kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CommOpen.commOpenReads,
handler = handleCommOpen(kmBuilder),
errHandler = handleParseError
)
}
private def handleCommOpen(kmBuilder: KMBuilder)(commOpen: CommOpen) = {
val commId = commOpen.comm_id
val targetName = commOpen.target_name
val data = commOpen.data
logger.debug(
s"Received comm_open for target '$targetName' with id '$commId'")
val commWriter = new KernelCommWriter(actorLoader, kmBuilder, commId)
commStorage.getTargetCallbacks(targetName) match {
case None =>
logger.warn(s"Received invalid target for Comm Open: $targetName")
commWriter.close()
case Some(callbacks) =>
logger.debug(s"Executing open callbacks for id '$commId'")
// TODO: Should we be checking the return values? Probably not.
callbacks.executeOpenCallbacks(commWriter, commId, targetName, data)
.filter(_.isFailure).map(_.failed).foreach(throwable => {
logger.error("Comm open callback encountered an error!", throwable)
})
}
}
private def handleParseError(invalid: Seq[(JsPath, Seq[ValidationError])]) = {
// TODO: Determine proper response for a parse failure
logger.warn("Parse error for Comm Open! Not responding!")
}
}
Example 48
| Source File: CommCloseHandler.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.handler
import org.apache.toree.comm.{KernelCommWriter, CommRegistrar, CommWriter, CommStorage}
import org.apache.toree.global.ExecuteRequestState
import org.apache.toree.kernel.protocol.v5.content.CommClose
import org.apache.toree.kernel.protocol.v5.kernel.{Utilities, ActorLoader}
import org.apache.toree.kernel.protocol.v5.{KMBuilder, KernelMessage}
import org.apache.toree.utils.MessageLogSupport
import play.api.data.validation.ValidationError
import play.api.libs.json.JsPath
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
class CommCloseHandler(
actorLoader: ActorLoader, commRegistrar: CommRegistrar,
commStorage: CommStorage
) extends BaseHandler(actorLoader) with MessageLogSupport
{
override def process(kernelMessage: KernelMessage): Future[_] = Future {
logKernelMessageAction("Initiating Comm Close for", kernelMessage)
ExecuteRequestState.processIncomingKernelMessage(kernelMessage)
val kmBuilder = KMBuilder().withParent(kernelMessage)
Utilities.parseAndHandle(
kernelMessage.contentString,
CommClose.commCloseReads,
handler = handleCommClose(kmBuilder),
errHandler = handleParseError
)
}
private def handleCommClose(kmBuilder: KMBuilder)(commClose: CommClose) = {
val commId = commClose.comm_id
val data = commClose.data
logger.debug(s"Received comm_close with id '$commId'")
val commWriter = new KernelCommWriter(actorLoader, kmBuilder, commId)
commStorage.getCommIdCallbacks(commId) match {
case None =>
logger.warn(s"Received invalid id for Comm Close: $commId")
case Some(callbacks) =>
logger.debug(s"Executing close callbacks for id '$commId'")
// TODO: Should we be checking the return values? Probably not.
callbacks.executeCloseCallbacks(commWriter, commId, data)
.filter(_.isFailure).map(_.failed).foreach(throwable => {
logger.error("Comm close callback encountered an error!", throwable)
})
}
}
private def handleParseError(invalid: Seq[(JsPath, Seq[ValidationError])]) = {
// TODO: Determine proper response for a parse failure
logger.warn("Parse error for Comm Close! Not responding!")
}
}
Example 49
| Source File: Utilities.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.kernel
import java.nio.charset.Charset
import akka.util.{ByteString, Timeout}
import org.apache.toree.communication.ZMQMessage
import org.apache.toree.kernel.protocol.v5._
import org.apache.toree.utils.LogLike
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, Json, Reads}
import scala.concurrent.duration._
object Utilities extends LogLike {
//
// NOTE: This is brought in to remove feature warnings regarding the use of
// implicit conversions regarding the following:
//
// 1. ByteStringToString
// 2. ZMQMessageToKernelMessage
//
import scala.language.implicitConversions
implicit val timeout = Timeout(21474835.seconds)
implicit def ByteStringToString(byteString : ByteString) : String = {
new String(byteString.toArray, Charset.forName("UTF-8"))
}
implicit def StringToByteString(string : String) : ByteString = {
ByteString(string.getBytes)
}
implicit def ZMQMessageToKernelMessage(message: ZMQMessage): KernelMessage = {
val delimiterIndex: Int =
message.frames.indexOf(ByteString("<IDS|MSG>".getBytes))
// TODO Handle the case where there is no delimiter
val ids: Seq[Array[Byte]] =
message.frames.take(delimiterIndex).map(
(byteString : ByteString) => { byteString.toArray }
)
val header = Json.parse(message.frames(delimiterIndex + 2)).as[Header]
// TODO: Investigate better solution than setting parentHeader to null for {}
val parentHeader = parseAndHandle(message.frames(delimiterIndex + 3),
ParentHeader.headerReads,
handler = (valid: ParentHeader) => valid,
errHandler = _ => null
)
val metadata = Json.parse(message.frames(delimiterIndex + 4)).as[Metadata]
KMBuilder().withIds(ids.toList)
.withSignature(message.frame(delimiterIndex + 1))
.withHeader(header)
.withParentHeader(parentHeader)
.withMetadata(metadata)
.withContentString(message.frame(delimiterIndex + 5)).build(false)
}
implicit def KernelMessageToZMQMessage(kernelMessage : KernelMessage) : ZMQMessage = {
val frames: scala.collection.mutable.ListBuffer[ByteString] = scala.collection.mutable.ListBuffer()
kernelMessage.ids.map((id : Array[Byte]) => frames += ByteString.apply(id) )
frames += "<IDS|MSG>"
frames += kernelMessage.signature
frames += Json.toJson(kernelMessage.header).toString()
frames += Json.toJson(kernelMessage.parentHeader).toString()
frames += Json.toJson(kernelMessage.metadata).toString
frames += kernelMessage.contentString
ZMQMessage(frames : _*)
}
def parseAndHandle[T, U](json: String, reads: Reads[T],
handler: T => U) : U = {
parseAndHandle(json, reads, handler,
(invalid: Seq[(JsPath, Seq[ValidationError])]) => {
logger.error(s"Could not parse JSON, ${json}")
throw new Throwable(s"Could not parse JSON, ${json}")
}
)
}
def parseAndHandle[T, U](json: String, reads: Reads[T],
handler: T => U,
errHandler: Seq[(JsPath, Seq[ValidationError])] => U) : U = {
Json.parse(json).validate[T](reads).fold(
errHandler,
(content: T) => handler(content)
)
}
}
Example 50
| Source File: SocketConfigSpec.scala From incubator-toree with Apache License 2.0 | 5 votes |
|
package org.apache.toree.kernel.protocol.v5.kernel.socket
import com.typesafe.config.ConfigFactory
import org.scalatest.{FunSpec, Matchers}
import org.slf4j.LoggerFactory
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsValue, Json}
class SocketConfigSpec extends FunSpec with Matchers {
val logger = LoggerFactory.getLogger("jt4")
//logger.error("WOOT!")
private val jsonString: String =
"""
{
"stdin_port": 10000,
"control_port": 10001,
"hb_port": 10002,
"shell_port": 10003,
"iopub_port": 10004,
"ip": "1.2.3.4",
"transport": "tcp",
"signature_scheme": "hmac-sha256",
"key": ""
}
""".stripMargin
val socketConfigJson: JsValue = Json.parse(jsonString)
val socketConfigFromConfig = SocketConfig.fromConfig(ConfigFactory.parseString(jsonString))
val socketConfig = SocketConfig(
10000, 10001, 10002, 10003, 10004, "1.2.3.4", "tcp", "hmac-sha256", ""
)
describe("SocketConfig") {
describe("implicit conversions") {
it("should implicitly convert from valid json to a SocketConfig instance") {
// This is the least safe way to convert as an error is thrown if it fails
socketConfigJson.as[SocketConfig] should be (socketConfig)
}
it("should also work with asOpt") {
// This is safer, but we lose the error information as it returns
// None if the conversion fails
val newCompleteRequest = socketConfigJson.asOpt[SocketConfig]
newCompleteRequest.get should be (socketConfig)
}
it("should also work with validate") {
// This is the safest as it collects all error information (not just first error) and reports it
val CompleteRequestResults = socketConfigJson.validate[SocketConfig]
CompleteRequestResults.fold(
(invalid: Seq[(JsPath, Seq[ValidationError])]) => println("Failed!"),
(valid: SocketConfig) => valid
) should be (socketConfig)
}
it("should implicitly convert from a SocketConfig instance to valid json") {
Json.toJson(socketConfig) should be (socketConfigJson)
}
}
describe("#toConfig") {
it("should implicitly convert from valid json to a SocketConfig instance") {
// This is the least safe way to convert as an error is thrown if it fails
socketConfigFromConfig should be (socketConfig)
}
it("should convert json file to SocketConfig object") {
socketConfigFromConfig.stdin_port should be (10000)
}
}
}
}
Example 51
| Source File: ItemAdded.scala From lagom with Apache License 2.0 | 5 votes |
|
package docs.home.scaladsl.serialization.v2c
import com.lightbend.lagom.scaladsl.playjson.JsonMigration
import com.lightbend.lagom.scaladsl.playjson.JsonMigrations
import com.lightbend.lagom.scaladsl.playjson.JsonSerializerRegistry
import play.api.libs.json.JsObject
import play.api.libs.json.JsPath
import play.api.libs.json.JsString
import scala.collection.immutable
//#rename
case class ItemAdded(shoppingCartId: String, itemId: String, quantity: Int)
//#rename
object ItemAddedMigration {
class ShopSerializerRegistry1 extends JsonSerializerRegistry {
override def serializers = Vector.empty
//#imperative-migration
private val itemAddedMigration = new JsonMigration(2) {
override def transform(fromVersion: Int, json: JsObject): JsObject = {
if (fromVersion < 2) {
val productId = (JsPath \ "productId").read[JsString].reads(json).get
json + ("itemId" -> productId) - "productId"
} else {
json
}
}
}
override def migrations = Map[String, JsonMigration](
classOf[ItemAdded].getName -> itemAddedMigration
)
//#imperative-migration
}
class ShopSerializerRegistry2 extends JsonSerializerRegistry {
override val serializers = Vector.empty
//#transformer-migration
val productIdToItemId =
JsPath.json
.update(
(JsPath \ "itemId").json.copyFrom((JsPath \ "productId").json.pick)
)
.andThen((JsPath \ "productId").json.prune)
override def migrations = Map[String, JsonMigration](
JsonMigrations.transform[ItemAdded](
immutable.SortedMap(
1 -> productIdToItemId
)
)
)
//#transformer-migration
}
}
Example 52
| Source File: Customer.scala From lagom with Apache License 2.0 | 5 votes |
|
package docs.home.scaladsl.serialization.v2a
import com.lightbend.lagom.scaladsl.playjson.JsonMigration
import com.lightbend.lagom.scaladsl.playjson.JsonSerializerRegistry
import play.api.libs.json.JsObject
import play.api.libs.json.JsPath
import play.api.libs.json.Json
import play.api.libs.json.Reads
import scala.collection.immutable.Seq
//#structural
case class Address(street: String, city: String, zipCode: String, country: String)
case class Customer(name: String, address: Address, shippingAddress: Option[Address])
//#structural
object Customer {
implicit val addressFormat = Json.format[Address]
val customerFormat = Json.format[Customer]
}
class CustomerMigration extends JsonSerializerRegistry {
override def serializers = Seq.empty
// format: off
//#structural-migration
import play.api.libs.json._
import play.api.libs.functional.syntax._
val customerMigration = new JsonMigration(2) {
// use arbitrary logic to parse an Address
// out of the old schema
val readOldAddress: Reads[Address] = {
(JsPath \ "street")
.read[String]
.and(
(JsPath \ "city").read[String])
.and(
(JsPath \ "zipCode").read[String])
.and(
(JsPath \ "country").read[String])(Address)
}
override def transform(fromVersion: Int, json: JsObject): JsObject = {
if (fromVersion < 2) {
val address = readOldAddress.reads(json).get
val withoutOldAddress = json - "street" - "city" - "zipCode" - "country"
// use existing formatter to write the address in the new schema
withoutOldAddress + ("address" -> Customer.addressFormat.writes(address))
} else {
json
}
}
}
override def migrations: Map[String, JsonMigration] = Map(
classOf[Customer].getName -> customerMigration
)
//#structural-migration
// format: on
}
Example 53
| Source File: JsonSerializationFailed.scala From lagom with Apache License 2.0 | 5 votes |
|
package com.lightbend.lagom.scaladsl.playjson
import scala.collection.Seq
import play.api.libs.json.JsPath
import play.api.libs.json.JsValue
import play.api.libs.json.Json
import play.api.libs.json.JsonValidationError
class JsonSerializationFailed private[lagom] (
message: String,
errors: Seq[(JsPath, Seq[JsonValidationError])],
json: JsValue
) extends RuntimeException {
override def getMessage: String =
s"$message\nerrors:\n${errors.map(errorToString).mkString("\t", "\n\t", "\n")}}\n${Json.prettyPrint(json)}"
private def errorToString(t: (JsPath, Seq[JsonValidationError])) = t match {
case (path, pathErrors) => s"$path: " + pathErrors.mkString(", ")
}
}
Example 54
| Source File: ReCaptchaService.scala From silhouette-vuejs-app with Apache License 2.0 | 5 votes |
|
package models.services.captcha
import javax.inject.Inject
import play.api.libs.json.{JsPath, Reads}
import play.api.libs.functional.syntax._
import play.api.libs.ws.WSClient
import scala.concurrent.{ExecutionContext, Future}
trait CaptchaService {
def validate(response: String, remoteIp: String): Future[Boolean]
}
class ReCaptchaService @Inject()(config: ReCaptchaConfig, ws: WSClient)(implicit ec: ExecutionContext) extends CaptchaService {
def validate(recaptchaResponse: String, remoteIp: String) = {
ws
.url("https://www.google.com/recaptcha/api/siteverify")
.withHttpHeaders("Accept" -> "application/json")
.withQueryStringParameters(
"secret" -> config.secretKey,
"response" -> recaptchaResponse,
"remoteip" -> remoteIp
)
.get()
.map(r => r.json.as[ReCaptchaValidationResponse])
.map { r =>
val e = r.errors.getOrElse(Vector())
if (e.isEmpty) {
r.success
} else {
throw new Exception("Failed to retrieve reCaptcha confirmed response: " + e.mkString(";"))
}
}
}
}
case class ReCaptchaConfig(secretKey: String)
private[captcha] case class ReCaptchaValidationResponse(success: Boolean, errors: Option[Vector[String]])
private[captcha] object ReCaptchaValidationResponse {
implicit val reads: Reads[ReCaptchaValidationResponse] = (
(JsPath \ "success").read[Boolean] and
(JsPath \ "error-codes").readNullable[Vector[String]]
) (ReCaptchaValidationResponse.apply _)
}
Example 55
| Source File: Allocation.scala From cluster-broccoli with Apache License 2.0 | 5 votes |
|
package de.frosner.broccoli.nomad.models
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Reads}
import shapeless.tag
import shapeless.tag.@@
final case class Allocation(
id: String @@ Allocation.Id,
jobId: String @@ Job.Id,
nodeId: String @@ Node.Id,
clientStatus: ClientStatus,
taskStates: Map[String @@ Task.Name, TaskStateEvents]
)
object Allocation {
trait Id
implicit val allocationReads: Reads[Allocation] =
((JsPath \ "ID").read[String].map(tag[Allocation.Id](_)) and
(JsPath \ "JobID").read[String].map(tag[Job.Id](_)) and
(JsPath \ "NodeID").read[String].map(tag[Node.Id](_)) and
(JsPath \ "ClientStatus").read[ClientStatus] and
(JsPath \ "TaskStates")
.readNullable[Map[String, TaskStateEvents]]
// Tag all values as task name. Since Task.Name is a phantom type this is a safe thing to do, albeit it doesn't
// look like so
.map(_.getOrElse(Map.empty).asInstanceOf[Map[String @@ Task.Name, TaskStateEvents]]))(Allocation.apply _)
}
