digital-asset/daml
1
1
Fork 0
mirror of https://github.com/digital-asset/daml.git synced 2024-09-19 16:57:40 +03:00
Code Issues Projects Releases Wiki Activity

use daml-lf scalacopts for ledger-service (#6569)

Browse Source 
* add lf_scalacopts to ledger-service/ projects

* handle unused warnings in http-json main

* handle unused warnings in lf-value-json

* handle unused warnings in http-json tests

* handle unused warnings in jwt

* JwtGenerator.generate doesn't use its argument; remove it

* no changelog

CHANGELOG_BEGIN
CHANGELOG_END

* format bazel files
This commit is contained in:
Stephen Compall 2020-07-02 09:58:41 -04:00 committed by GitHub
parent 6dc2c9c9b8
commit 9fb72202d8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 86 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ledger-service/db-backend/BUILD.bazel
View File

@ -44,6 +44,7 @@ da_scala_test(
name = "tests",
size = "medium",
srcs = glob(["src/test/scala/**/*.scala"]),
scalacopts = lf_scalacopts,
# data = ["//docs:quickstart-model.dar"],
deps = [
":db-backend",

7
ledger-service/http-json/BUILD.bazel
View File

@ -6,10 +6,11 @@ load(
"da_scala_binary",
"da_scala_library",
"da_scala_test",
"lf_scalacopts",
)
load("//rules_daml:daml.bzl", "daml_compile")
hj_scalacopts = [
hj_scalacopts = lf_scalacopts + [
"-P:wartremover:traverser:org.wartremover.warts.NonUnitStatements",
]
@ -157,10 +158,11 @@ da_scala_test(
"//ledger/test-common/test-certificates",
],
plugins = [
"@maven//:com_github_ghik_silencer_plugin_2_12_11",
"@maven//:org_spire_math_kind_projector_2_12",
],
resources = glob(["src/it/resources/**/*"]),
scalacopts = hj_scalacopts,
scalacopts = hj_scalacopts + ["-P:silencer:checkUnused"],
deps = [
":http-json",
"//bazel_tools/runfiles:scala_runfiles",
@ -182,6 +184,7 @@ da_scala_test(
"//libs-scala/postgresql-testing",
"@maven//:ch_qos_logback_logback_classic",
"@maven//:com_chuusai_shapeless_2_12",
"@maven//:com_github_ghik_silencer_lib_2_12_11",
"@maven//:com_lihaoyi_sourcecode_2_12",
"@maven//:com_typesafe_akka_akka_http_core_2_12",
"@maven//:com_typesafe_scala_logging_scala_logging_2_12",

27
ledger-service/http-json/src/it/scala/http/AbstractHttpServiceIntegrationTest.scala
View File

@ -215,7 +215,6 @@ trait AbstractHttpServiceIntegrationTestFuns extends StrictLogging {
contractId: ContractId,
create: domain.CreateCommand[v.Record],
encoder: DomainJsonEncoder,
decoder: DomainJsonDecoder,
uri: Uri): Future[Assertion] =
postContractsLookup(contractLocator, uri).flatMap {
case (status, output) =>
@ -223,7 +222,7 @@ trait AbstractHttpServiceIntegrationTestFuns extends StrictLogging {
assertStatus(output, StatusCodes.OK)
val result = getResult(output)
contractId shouldBe getContractId(result)
assertActiveContract(result)(create, encoder, decoder)
assertActiveContract(result)(create, encoder)
}
protected def removeRecordId(a: v.Value): v.Value = a match {
@ -408,8 +407,7 @@ trait AbstractHttpServiceIntegrationTestFuns extends StrictLogging {
protected def assertActiveContract(jsVal: JsValue)(
command: domain.CreateCommand[v.Record],
encoder: DomainJsonEncoder,
decoder: DomainJsonDecoder): Assertion = {
encoder: DomainJsonEncoder): Assertion = {
import encoder.implicits._
@ -660,7 +658,7 @@ abstract class AbstractHttpServiceIntegrationTest
}
}
"create IOU" in withHttpService { (uri, encoder, decoder) =>
"create IOU" in withHttpService { (uri, encoder, _) =>
val command: domain.CreateCommand[v.Record] = iouCreateCommand()
postCreateCommand(command, encoder, uri).flatMap {
@ -668,7 +666,7 @@ abstract class AbstractHttpServiceIntegrationTest
status shouldBe StatusCodes.OK
assertStatus(output, StatusCodes.OK)
val activeContract = getResult(output)
assertActiveContract(activeContract)(command, encoder, decoder)
assertActiveContract(activeContract)(command, encoder)
}: Future[Assertion]
}
@ -729,7 +727,6 @@ abstract class AbstractHttpServiceIntegrationTest
getResult(exerciseOutput),
create,
exercise,
encoder,
decoder,
uri)
}
@ -775,7 +772,6 @@ abstract class AbstractHttpServiceIntegrationTest
exerciseResponse: JsValue,
createCmd: domain.CreateCommand[v.Record],
exerciseCmd: domain.ExerciseCommand[v.Value, domain.EnrichedContractId],
encoder: DomainJsonEncoder,
decoder: DomainJsonDecoder,
uri: Uri
): Future[Assertion] = {
@ -820,7 +816,7 @@ abstract class AbstractHttpServiceIntegrationTest
}: Future[Assertion]
}
"exercise Archive" in withHttpService { (uri, encoder, decoder) =>
"exercise Archive" in withHttpService { (uri, encoder, _) =>
val create: domain.CreateCommand[v.Record] = iouCreateCommand()
postCreateCommand(create, encoder, uri)
.flatMap {
@ -840,13 +836,12 @@ abstract class AbstractHttpServiceIntegrationTest
exerciseStatus shouldBe StatusCodes.OK
assertStatus(exerciseOutput, StatusCodes.OK)
val exercisedResponse: JsObject = getResult(exerciseOutput).asJsObject
assertExerciseResponseArchivedContract(decoder, exercisedResponse, exercise)
assertExerciseResponseArchivedContract(exercisedResponse, exercise)
}
}: Future[Assertion]
}
private def assertExerciseResponseArchivedContract(
decoder: DomainJsonDecoder,
exerciseResponse: JsValue,
exercise: domain.ExerciseCommand[v.Value, domain.EnrichedContractId]
): Assertion = {
@ -1113,7 +1108,7 @@ abstract class AbstractHttpServiceIntegrationTest
}
}
"fetch by contractId" in withHttpService { (uri, encoder, decoder) =>
"fetch by contractId" in withHttpService { (uri, encoder, _) =>
val command: domain.CreateCommand[v.Record] = iouCreateCommand()
postCreateCommand(command, encoder, uri).flatMap {
@ -1122,7 +1117,7 @@ abstract class AbstractHttpServiceIntegrationTest
assertStatus(output, StatusCodes.OK)
val contractId: ContractId = getContractId(getResult(output))
val locator = domain.EnrichedContractId(None, contractId)
lookupContractAndAssert(locator)(contractId, command, encoder, decoder, uri)
lookupContractAndAssert(locator)(contractId, command, encoder, uri)
}: Future[Assertion]
}
@ -1145,7 +1140,7 @@ abstract class AbstractHttpServiceIntegrationTest
}: Future[Assertion]
}
"fetch by key" in withHttpService { (uri, encoder, decoder) =>
"fetch by key" in withHttpService { (uri, encoder, _) =>
val owner = domain.Party("Alice")
val accountNumber = "abc123"
val command: domain.CreateCommand[v.Record] = accountCreateCommand(owner, accountNumber)
@ -1159,11 +1154,11 @@ abstract class AbstractHttpServiceIntegrationTest
domain.TemplateId(None, "Account", "Account"),
JsArray(JsString(owner.unwrap), JsString(accountNumber))
)
lookupContractAndAssert(locator)(contractId, command, encoder, decoder, uri)
lookupContractAndAssert(locator)(contractId, command, encoder, uri)
}: Future[Assertion]
}
"commands/exercise Archive by key" in withHttpService { (uri, encoder, decoder) =>
"commands/exercise Archive by key" in withHttpService { (uri, encoder, _) =>
val owner = domain.Party("Alice")
val accountNumber = "abc123"
val create: domain.CreateCommand[v.Record] = accountCreateCommand(owner, accountNumber)

4
ledger-service/http-json/src/it/scala/http/HttpServiceTestFixture.scala
View File

@ -14,7 +14,6 @@ import com.daml.grpc.adapter.ExecutionSequencerFactory
import com.daml.http.dbbackend.ContractDao
import com.daml.http.json.{DomainJsonDecoder, DomainJsonEncoder}
import com.daml.http.util.{FutureUtil, NewBoolean}
import com.daml.http.util.IdentifierConverters.apiLedgerId
import com.daml.ledger.api.auth.AuthService
import com.daml.ledger.api.domain.LedgerId
import com.daml.ledger.api.refinements.ApiTypes.ApplicationId
@ -191,13 +190,12 @@ object HttpServiceTestFixture {
def jsonCodecs(client: LedgerClient)(
implicit ec: ExecutionContext): Future[(DomainJsonEncoder, DomainJsonDecoder)] = {
val ledgerId = apiLedgerId(client.ledgerId)
val packageService = new PackageService(
HttpService.loadPackageStoreUpdates(client.packageClient, holderM = None))
packageService
.reload(ec)
.flatMap(x => FutureUtil.toFuture(x))
.map(_ => HttpService.buildJsonCodecs(ledgerId, packageService))
.map(_ => HttpService.buildJsonCodecs(packageService))
}
private def stripLeft(fa: Future[HttpService.Error \/ ServerBinding])(

17
ledger-service/http-json/src/it/scala/http/WebsocketServiceIntegrationTest.scala
View File

@ -335,6 +335,7 @@ class WebsocketServiceIntegrationTest
{"templateIds": ["Iou:Iou"]}
]"""
@com.github.ghik.silencer.silent("evtsWrapper.*never used")
def resp(iouCid: domain.ContractId): Sink[JsValue, Future[ShouldHaveEnded]] = {
val dslSyntax = Consume.syntax[JsValue]
import dslSyntax._
@ -408,7 +409,7 @@ class WebsocketServiceIntegrationTest
via parseResp runWith remainingDeltas)
} yield
inside(rescan) {
case (Vector((fstId, fst), (sndId, snd)), Vector(observeConsumed), Some(_)) =>
case (Vector((fstId, fst @ _), (sndId, snd @ _)), Vector(observeConsumed), Some(_)) =>
Set(fstId, sndId, observeConsumed.contractId) should have size 3
}
}
@ -544,9 +545,9 @@ class WebsocketServiceIntegrationTest
def go(
createdCid: domain.ContractId,
ss: SplitSeq[BigDecimal]): Consume.FCC[IouSplitResult, Assertion] = ss match {
case Leaf(x) =>
case Leaf(_) =>
point(1 shouldBe 1)
case Node(x, l, r) =>
case Node(_, l, r) =>
for {
(StatusCodes.OK, _) <- liftF(
TestUtil.postJsonRequest(
@ -723,16 +724,6 @@ object WebsocketServiceIntegrationTest {
def dummyFlow[A](source: Source[A, NotUsed]): Flow[A, A, NotUsed] =
Flow.fromSinkAndSource(Sink.foreach(println), source)
private def foldWhile[S, A, T](zero: S)(f: (S, A) => (S \/ T)): Sink[A, Future[Option[T]]] =
Flow[A]
.scan(-\/(zero): S \/ T)((st, a) =>
st match {
case -\/(s) => f(s, a)
case \/-(_) => st
})
.collect { case \/-(t) => t }
.toMat(Sink.headOption)(Keep.right)
private val contractIdAtOffsetKey = "contractIdAtOffset"
private case class SimpleScenario(id: String, path: Uri.Path, input: Source[Message, NotUsed])

2
ledger-service/http-json/src/main/scala/com/digitalasset/http/CommandService.scala
View File

@ -3,7 +3,6 @@
package com.daml.http
import com.daml.api.util.TimeProvider
import com.daml.lf.data.ImmArray.ImmArraySeq
import com.daml.http.ErrorMessages.cannotResolveTemplateId
import com.daml.http.domain.{
@ -36,7 +35,6 @@ class CommandService(
resolveTemplateId: PackageService.ResolveTemplateId,
submitAndWaitForTransaction: LedgerClientJwt.SubmitAndWaitForTransaction,
submitAndWaitForTransactionTree: LedgerClientJwt.SubmitAndWaitForTransactionTree,
timeProvider: TimeProvider,
)(implicit ec: ExecutionContext)
extends StrictLogging {

7
ledger-service/http-json/src/main/scala/com/digitalasset/http/ContractsFetch.scala
View File

@ -52,7 +52,6 @@ private class ContractsFetch(
getActiveContracts: LedgerClientJwt.GetActiveContracts,
getCreatesAndArchivesSince: LedgerClientJwt.GetCreatesAndArchivesSince,
getTermination: LedgerClientJwt.GetTermination,
lookupType: query.ValuePredicate.TypeLookup,
)(implicit dblog: doobie.LogHandler)
extends StrictLogging {
@ -293,8 +292,10 @@ private[http] object ContractsFetch {
/** Several of the graphs here have a second output guaranteed to deliver only one value.
* This turns such a graph into a flow with the value materialized.
*/
def divertToHead(implicit noM: M <~< NotUsed): Flow[A, Y, Future[Z]] =
divertToMat(Sink.head)(Keep.right[M, Future[Z]])
def divertToHead(implicit noM: M <~< NotUsed): Flow[A, Y, Future[Z]] = {
type CK[-A] = (A, Future[Z]) => Future[Z]
divertToMat(Sink.head)(noM.subst[CK](Keep.right[NotUsed, Future[Z]]))
}
}
}

7
ledger-service/http-json/src/main/scala/com/digitalasset/http/ContractsService.scala
View File

@ -39,7 +39,6 @@ class ContractsService(
getTermination: LedgerClientJwt.GetTermination,
lookupType: query.ValuePredicate.TypeLookup,
contractDao: Option[dbbackend.ContractDao],
parallelism: Int = 8,
)(implicit ec: ExecutionContext, mat: Materializer)
extends StrictLogging {
@ -55,7 +54,6 @@ class ContractsService(
getActiveContracts,
getCreatesAndArchivesSince,
getTermination,
lookupType,
)(
dao.logHandler,
),
@ -223,12 +221,11 @@ class ContractsService(
for {
_ <- fetch.fetchAndPersist(jwt, party, templateIds.toList)
cts <- templateIds.toVector
.traverse(tpId => searchDbOneTpId_(fetch, doobieLog)(jwt, party, tpId, queryParams))
.traverse(tpId => searchDbOneTpId_(doobieLog)(party, tpId, queryParams))
} yield cts.flatten
}
private[this] def searchDbOneTpId_(fetch: ContractsFetch, doobieLog: doobie.LogHandler)(
jwt: Jwt,
private[this] def searchDbOneTpId_(doobieLog: doobie.LogHandler)(
party: domain.Party,
templateId: domain.TemplateId.RequiredPkg,
queryParams: Map[String, JsValue],

2
ledger-service/http-json/src/main/scala/com/digitalasset/http/Endpoints.scala
View File

@ -26,7 +26,6 @@ import com.daml.http.util.Collections.toNonEmptySet
import com.daml.http.util.FutureUtil.{either, eitherT}
import com.daml.http.util.ProtobufByteStrings
import com.daml.jwt.domain.Jwt
import com.daml.ledger.api.refinements.{ApiTypes => lar}
import com.daml.ledger.api.{v1 => lav1}
import com.daml.util.ExceptionOps._
import com.typesafe.scalalogging.StrictLogging
@ -42,7 +41,6 @@ import scala.util.Try
import scala.util.control.NonFatal
class Endpoints(
ledgerId: lar.LedgerId,
allowNonHttps: Boolean,
decodeJwt: EndpointsCompanion.ValidateJwt,
commandService: CommandService,

10
ledger-service/http-json/src/main/scala/com/digitalasset/http/EndpointsCompanion.scala
View File

@ -20,15 +20,15 @@ object EndpointsCompanion {
type ValidateJwt = Jwt => Unauthorized \/ DecodedJwt[String]
sealed abstract class Error(message: String) extends Product with Serializable
sealed abstract class Error extends Product with Serializable
final case class InvalidUserInput(message: String) extends Error(message)
final case class InvalidUserInput(message: String) extends Error
final case class Unauthorized(message: String) extends Error(message)
final case class Unauthorized(message: String) extends Error
final case class ServerError(message: String) extends Error(message)
final case class ServerError(message: String) extends Error
final case class NotFound(message: String) extends Error(message)
final case class NotFound(message: String) extends Error
object Error {
implicit val ShowInstance: Show[Error] = Show shows {

8
ledger-service/http-json/src/main/scala/com/digitalasset/http/HttpService.scala
View File

@ -10,7 +10,6 @@ import akka.http.scaladsl.Http
import akka.http.scaladsl.Http.ServerBinding
import akka.http.scaladsl.settings.ServerSettings
import akka.stream.Materializer
import com.daml.api.util.TimeProvider
import com.daml.auth.TokenHolder
import com.daml.grpc.adapter.ExecutionSequencerFactory
import com.daml.http.Statement.discard
@ -129,7 +128,6 @@ object HttpService extends StrictLogging {
packageService.resolveTemplateId,
LedgerClientJwt.submitAndWaitForTransaction(client),
LedgerClientJwt.submitAndWaitForTransactionTree(client),
TimeProvider.UTC,
)
contractsService = new ContractsService(
@ -156,10 +154,9 @@ object HttpService extends StrictLogging {
() => packageService.reload(ec))
)
(encoder, decoder) = buildJsonCodecs(ledgerId, packageService)
(encoder, decoder) = buildJsonCodecs(packageService)
jsonEndpoints = new Endpoints(
ledgerId,
allowNonHttps,
validateJwt,
commandService,
@ -173,14 +170,12 @@ object HttpService extends StrictLogging {
websocketService = new WebSocketService(
contractsService,
packageService.resolveTemplateId,
encoder,
decoder,
LedgerReader.damlLfTypeLookup(packageService.packageStore _),
wsConfig,
)
websocketEndpoints = new WebsocketEndpoints(
ledgerId,
validateJwt,
websocketService,
)
@ -239,7 +234,6 @@ object HttpService extends StrictLogging {
jwt => JwtDecoder.decode(jwt).leftMap(e => EndpointsCompanion.Unauthorized(e.shows))
private[http] def buildJsonCodecs(
ledgerId: lar.LedgerId,
packageService: PackageService,
): (DomainJsonEncoder, DomainJsonDecoder) = {

8
ledger-service/http-json/src/main/scala/com/digitalasset/http/PartiesService.scala
View File

@ -63,14 +63,6 @@ class PartiesService(
et.run
}
private def collectParties(
xs: List[api.domain.PartyDetails],
requested: Set[String]
): Set[domain.PartyDetails] =
xs.iterator.collect {
case p if requested(p.party) => domain.PartyDetails.fromLedgerApi(p)
}.toSet
private def findUnknownParties(
found: Set[domain.PartyDetails],
requested: OneAnd[Set, domain.Party]

3
ledger-service/http-json/src/main/scala/com/digitalasset/http/WebSocketService.scala
View File

@ -9,7 +9,7 @@ import akka.stream.scaladsl.{Flow, Source, Sink}
import akka.stream.Materializer
import com.daml.http.EndpointsCompanion._
import com.daml.http.domain.{JwtPayload, SearchForeverRequest}
import com.daml.http.json.{DomainJsonDecoder, DomainJsonEncoder, JsonProtocol, SprayJson}
import com.daml.http.json.{DomainJsonDecoder, JsonProtocol, SprayJson}
import com.daml.http.LedgerClientJwt.Terminates
import util.ApiValueToLfValueConverter.apiValueToLfValue
import util.{AbsoluteBookmark, ContractStreamStep, InsertDeleteStep, LedgerBegin}
@ -286,7 +286,6 @@ object WebSocketService {
class WebSocketService(
contractsService: ContractsService,
resolveTemplateId: PackageService.ResolveTemplateId,
encoder: DomainJsonEncoder,
decoder: DomainJsonDecoder,
lookupType: ValuePredicate.TypeLookup,
wsConfig: Option[WebsocketConfig])(implicit mat: Materializer, ec: ExecutionContext)

8
ledger-service/http-json/src/main/scala/com/digitalasset/http/WebsocketEndpoints.scala
View File

@ -6,16 +6,14 @@ package com.daml.http
import akka.http.scaladsl.model.HttpMethods._
import akka.http.scaladsl.model._
import akka.http.scaladsl.model.ws.{Message, UpgradeToWebSocket}
import akka.stream.Materializer
import akka.stream.scaladsl.Flow
import com.daml.jwt.domain.Jwt
import com.daml.ledger.api.refinements.{ApiTypes => lar}
import com.typesafe.scalalogging.StrictLogging
import scalaz.syntax.std.boolean._
import scalaz.syntax.std.option._
import scalaz.\/
import scala.concurrent.{ExecutionContext, Future}
import scala.concurrent.Future
import EndpointsCompanion._
object WebsocketEndpoints {
@ -47,11 +45,9 @@ object WebsocketEndpoints {
}
class WebsocketEndpoints(
ledgerId: lar.LedgerId,
decodeJwt: ValidateJwt,
webSocketService: WebSocketService,
)(implicit mat: Materializer, ec: ExecutionContext)
extends StrictLogging {
) extends StrictLogging {
import WebsocketEndpoints._

2
ledger-service/http-json/src/main/scala/com/digitalasset/http/query/ValuePredicate.scala
View File

@ -321,7 +321,7 @@ object ValuePredicate {
}
(typ match {
case tc @ iface.TypeCon(iface.TypeConName(id), typArgs) =>
case tc @ iface.TypeCon(iface.TypeConName(id), typArgs @ _) =>
for {
dt <- defs(id)
recTy <- tc instantiate dt match { case r @ iface.Record(_) => Some(r); case _ => None }

4
ledger-service/jwt/BUILD.bazel
View File

@ -6,11 +6,13 @@ load(
"da_scala_binary",
"da_scala_library",
"da_scala_test",
"lf_scalacopts",
)
da_scala_library(
name = "jwt",
srcs = glob(["src/main/scala/**/*.scala"]),
scalacopts = lf_scalacopts,
tags = ["maven_coordinates=com.daml:jwt:__VERSION__"],
visibility = ["//visibility:public"],
runtime_deps = [
@ -32,6 +34,7 @@ da_scala_binary(
name = "jwt-bin",
srcs = glob(["src/main/scala/**/*.scala"]),
main_class = "com.daml.jwt.Main",
scalacopts = lf_scalacopts,
runtime_deps = [
":jwt",
"@maven//:ch_qos_logback_logback_classic",
@ -53,6 +56,7 @@ da_scala_test(
size = "medium",
srcs = glob(["src/test/scala/**/*.scala"]),
resources = glob(["src/test/resources/**/*"]),
scalacopts = lf_scalacopts,
deps = [
":jwt",
"@maven//:com_auth0_java_jwt",

2
ledger-service/jwt/src/main/scala/com/digitalasset/jwt/JwtGenerator.scala
View File

@ -6,5 +6,5 @@ package com.daml.jwt
import scala.util.Try
object JwtGenerator {
def generate(keys: domain.KeyPair[Seq[Byte]]): Try[domain.Jwt] = Try(domain.Jwt("dummy"))
def generate: Try[domain.Jwt] = Try(domain.Jwt("dummy"))
}

74
ledger-service/jwt/src/main/scala/com/digitalasset/jwt/KeyUtils.scala
View File

@ -61,56 +61,50 @@ object KeyUtils {
* Reads a RSA private key from a PEM/PKCS#8 file.
* These usually have the .pem file extension.
*/
def readRSAPrivateKeyFromPem(file: File): Try[RSAPrivateKey] = {
bracket(Try(new FileInputStream(file)))(is => Try(is.close())).flatMap { istream =>
for {
fileContent <- Try(Files.readAllBytes(file.toPath))
def readRSAPrivateKeyFromPem(file: File): Try[RSAPrivateKey] =
for {
fileContent <- Try(Files.readAllBytes(file.toPath))
// Remove PEM container header and footer
pemContent <- Try(
new String(fileContent, mimeCharSet)
.replaceFirst("-----BEGIN ([A-Z ])*-----\n", "")
.replaceFirst("\n-----END ([A-Z ])*-----\n", "")
.replace("\r", "")
.replace("\n", "")
)
// Remove PEM container header and footer
pemContent <- Try(
new String(fileContent, mimeCharSet)
.replaceFirst("-----BEGIN ([A-Z ])*-----\n", "")
.replaceFirst("\n-----END ([A-Z ])*-----\n", "")
.replace("\r", "")
.replace("\n", "")
)
// Base64-decode the PEM container content
decoded <- Base64
.decode(pemContent)
.leftMap(e => new RuntimeException(e.shows))
.toEither
.toTry
// Base64-decode the PEM container content
decoded <- Base64
.decode(pemContent)
.leftMap(e => new RuntimeException(e.shows))
.toEither
.toTry
// Interpret the container content as PKCS#8
key <- Try {
val kf = KeyFactory.getInstance("RSA")
val keySpec = new PKCS8EncodedKeySpec(decoded.getBytes)
kf.generatePrivate(keySpec).asInstanceOf[RSAPrivateKey]
}
} yield key
}
}
// Interpret the container content as PKCS#8
key <- Try {
val kf = KeyFactory.getInstance("RSA")
val keySpec = new PKCS8EncodedKeySpec(decoded.getBytes)
kf.generatePrivate(keySpec).asInstanceOf[RSAPrivateKey]
}
} yield key
/**
* Reads a RSA private key from a binary file (PKCS#8, DER).
* To generate this file from a .pem file, use the following command:
* openssl pkcs8 -topk8 -inform PEM -outform DER -in private-key.pem -nocrypt > private-key.der
*/
def readRSAPrivateKeyFromDer(file: File): Try[RSAPrivateKey] = {
bracket(Try(new FileInputStream(file)))(is => Try(is.close())).flatMap { istream =>
for {
fileContent <- Try(Files.readAllBytes(file.toPath))
def readRSAPrivateKeyFromDer(file: File): Try[RSAPrivateKey] =
for {
fileContent <- Try(Files.readAllBytes(file.toPath))
// Interpret the container content as PKCS#8
key <- Try {
val kf = KeyFactory.getInstance("RSA")
val keySpec = new PKCS8EncodedKeySpec(fileContent)
kf.generatePrivate(keySpec).asInstanceOf[RSAPrivateKey]
}
} yield key
}
}
// Interpret the container content as PKCS#8
key <- Try {
val kf = KeyFactory.getInstance("RSA")
val keySpec = new PKCS8EncodedKeySpec(fileContent)
kf.generatePrivate(keySpec).asInstanceOf[RSAPrivateKey]
}
} yield key
/**
* Generates a JWKS JSON object for the given map of KeyID->Key

5
ledger-service/jwt/src/main/scala/com/digitalasset/jwt/Main.scala
View File

@ -32,9 +32,8 @@ object Main {
e.printStackTrace()
sys.exit(ErrorCodes.GenerateKeysError)
}
case Some(Config(None, Some(GenerateJwt(Some(publicKey), Some(privateKey))))) =>
JwtGenerator.generate(
domain.KeyPair(publicKey = Seq.empty[Byte], privateKey = Seq.empty[Byte])) match {
case Some(Config(None, Some(GenerateJwt(Some(publicKey @ _), Some(privateKey @ _))))) =>
JwtGenerator.generate match {
case Success(a) =>
println(s"Generated JWT: $a")
case Failure(e) =>

3
ledger-service/lf-value-json/BUILD.bazel
View File

@ -5,6 +5,7 @@ load(
"//bazel_tools:scala.bzl",
"da_scala_library",
"da_scala_test",
"lf_scalacopts",
)
load(
"//rules_daml:daml.bzl",
@ -14,6 +15,7 @@ load(
da_scala_library(
name = "lf-value-json",
srcs = glob(["src/main/scala/**/*.scala"]),
scalacopts = lf_scalacopts,
tags = ["maven_coordinates=com.daml:lf-value-json:__VERSION__"],
visibility = [
"//visibility:public",
@ -39,6 +41,7 @@ da_scala_test(
data = [
":JsonEncodingTest.dar",
],
scalacopts = lf_scalacopts,
deps = [
":lf-value-json",
"//bazel_tools/runfiles:scala_runfiles",

4
ledger-service/lf-value-json/src/main/scala/com/digitalasset/daml/lf/value/json/ApiValueImplicits.scala
View File

@ -4,7 +4,7 @@
package com.daml.lf.value.json
import java.time.{Instant, LocalDate}
import java.time.format.{DateTimeFormatter, DateTimeFormatterBuilder}
import java.time.format.DateTimeFormatter
import com.daml.lf.data.Time
import com.daml.lf.value.{Value => V}
@ -25,8 +25,6 @@ object ApiValueImplicits {
}
// Timestamp has microsecond resolution
private val formatter: DateTimeFormatter =
new DateTimeFormatterBuilder().appendInstant(6).toFormatter()
implicit final class `ApiTimestamp.type additions`(private val it: V.ValueTimestamp.type)
extends AnyVal {
def fromIso8601(t: String): V.ValueTimestamp = fromInstant(Instant.parse(t))

3
ledger-service/utils/BUILD.bazel
View File

@ -5,11 +5,13 @@ load(
"//bazel_tools:scala.bzl",
"da_scala_library",
"da_scala_test_suite",
"lf_scalacopts",
)
da_scala_library(
name = "utils",
srcs = glob(["src/main/scala/**/*.scala"]),
scalacopts = lf_scalacopts,
tags = ["maven_coordinates=com.daml:http-json-utils:__VERSION__"],
visibility = ["//visibility:public"],
deps = [
@ -27,6 +29,7 @@ da_scala_test_suite(
name = "tests",
size = "small",
srcs = glob(["src/test/scala/**/*.scala"]),
scalacopts = lf_scalacopts,
deps = [
":utils",
],