Scala Platform类代码示例

//设置package包名称以及导入依赖的类
package fr.acinq.syscoin

import java.io._
import java.security._
import java.security.cert.{CertificateFactory, X509Certificate}
import java.security.spec.PKCS8EncodedKeySpec

import com.google.protobuf.ByteString
import org.syscoin.protocols.payments.Protos.{Output, PaymentDetails, PaymentRequest}
import org.bouncycastle.util.io.pem.PemReader
import org.junit.runner.RunWith
import org.scalatest.FlatSpec
import org.scalatest.junit.JUnitRunner

import scala.compat.Platform

@RunWith(classOf[JUnitRunner])
class PaymentProtocolSpec extends FlatSpec {
  val keystore = KeyStore.getInstance("JKS")
  keystore.load(classOf[PaymentProtocolSpec].getResourceAsStream("/cacerts"), null)
  val aliases = keystore.aliases()

  "Payment protocol" should "verify payment requests" in {
    val stream = classOf[PaymentProtocolSpec].getResourceAsStream("/r1411736682.syscoinpaymentrequest")
    val request = PaymentRequest.parseFrom(stream)
    val (name, publicKey, trustAnchor) = PaymentProtocol.verifySignature(request, keystore)
    assert(name === "www.syscoincore.org")

    // check that we get an exception if we attempt to modify payment details
    val details = PaymentDetails.parseFrom(request.getSerializedPaymentDetails)
    val request1 = request.toBuilder.setSerializedPaymentDetails(details.toBuilder.setPaymentUrl("foo").build().toByteString).build()
    intercept[RuntimeException] {
      PaymentProtocol.verifySignature(request1, keystore)
    }
  }
  it should "sign payment requests" in {
    val factory = CertificateFactory.getInstance("X.509")
    val cacert = factory.generateCertificate(classOf[PaymentProtocolSpec].getResourceAsStream("/cacert.pem")).asInstanceOf[X509Certificate]
    val servercert = factory.generateCertificate(classOf[PaymentProtocolSpec].getResourceAsStream("/servercert.pem")).asInstanceOf[X509Certificate]
    //val cert3 = factory.generateCertificate(classOf[PaymentProtocolSpec].getResourceAsStream("/ca-int2.crt")).asInstanceOf[X509Certificate]
    val keyPair = new PemReader(new InputStreamReader(classOf[PaymentProtocolSpec].getResourceAsStream("/serverkey.pem"))).readPemObject()
    val keyFactory = KeyFactory.getInstance("RSA")
    val key = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(keyPair.getContent))
    keystore.setCertificateEntry("foo", cacert)
    val details = PaymentDetails.newBuilder()
      .addOutputs(Output.newBuilder().setAmount(100).setScript(ByteString.EMPTY))
      .setMemo("foo")
      .setPaymentUrl("")
      .setTime(Platform.currentTime)

    val request = PaymentRequest.newBuilder()
      .setPaymentDetailsVersion(1)
      .setSerializedPaymentDetails(details.build().toByteString)
      .build

    val request1 = PaymentProtocol.sign(request, Seq(servercert), key)
    val (name, publicKey, trustAnchor) = PaymentProtocol.verifySignature(request1, keystore)
    assert(name === "Foobar")
  }
} 

//设置package包名称以及导入依赖的类
package com.github.dnvriend.perf

import com.github.dnvriend.IntegrationSpec

import scala.compat.Platform

class NormalSpec extends IntegrationSpec {

  it should "perform with type 'String'" in withSingleEntity { pid => entity =>
    val numberOfEvents = 10000
    val eventsSender = persistEvents(pid, entity, "NormalSpec", numberOfEvents)
    val eventsReader = readEvents(pid, numberOfEvents)

    val start = Platform.currentTime
    eventsSender.futureValue
    println(s"Writing events took: ${Platform.currentTime - start} ms")
    eventsReader.futureValue.size shouldBe numberOfEvents
    println(s"Reading events took: ${Platform.currentTime - start} ms")
  }
} 

//设置package包名称以及导入依赖的类
package com.github.dnvriend.perf

import com.github.dnvriend.IntegrationSpec

import scala.compat.Platform

class FastSpec extends IntegrationSpec {

  def writeEvents(numberOfEvents: Int): Unit = withRoundRobinEntity { pid => entity =>
      val eventsSender = persistEvents(pid, entity, "FastSpec", numberOfEvents)
      val eventsReader = readEvents(pid, numberOfEvents)

      val start = Platform.currentTime
      eventsSender.futureValue
      println(s"Writing events took: ${Platform.currentTime - start} ms")
      eventsReader.futureValue.size shouldBe numberOfEvents
      println(s"Reading events took: ${Platform.currentTime - start} ms")
  }

  it should "perform with type 'String'" in {
    (1 to 5).foreach( _ => writeEvents(10000))
  }
} 

//设置package包名称以及导入依赖的类
package com.evolutiongaming.util

import com.codahale.metrics.{Gauge, Histogram, MetricRegistry, Timer}

import scala.compat.Platform
import scala.concurrent.duration._
import scala.concurrent.{ExecutionContext, Future}
import scala.util.control.NonFatal

object MetricHelper {

  object GaugeF {
    def apply[T](f: => T): Gauge[T] = new Gauge[T] { def getValue: T = f }
  }

  implicit class RichTimer(val timer: Timer) extends AnyVal {
    def timeExceed[T](limit: FiniteDuration)(f: => T): T = {
      val start = Platform.currentTime
      try f finally {
        val stop = Platform.currentTime
        val duration = stop - start
        if (duration >= limit.toMillis) timer.update(duration, MILLISECONDS)
      }
    }

    def timeFuture[T](f: => Future[T])(implicit ec: ExecutionContext): Future[T] = {
      val time = timer.time()
      try f andThen { case _ => time.stop() } catch {
        case NonFatal(e) => time.stop(); throw e
      }
    }

    def timeFunc[T](f: => T): T = {
      val time = timer.time()
      try f finally time.stop()
    }
  }

  implicit class HistogramOps(val histogram: Histogram) extends AnyVal {
    def timeFunc[T](f: => T): T = {
      val start = Platform.currentTime
      try f finally histogram.update(Platform.currentTime - start)
    }

    def timeFuture[T](f: => Future[T])(implicit ec: ExecutionContext): Future[T] = {
      val start = Platform.currentTime
      f andThen { case _ => histogram.update(Platform.currentTime - start) }
    }
  }

  implicit class MetricRegistryOps(val self: MetricRegistry) extends AnyVal {
    def gauge[T](name: String, f: => T): Gauge[T] = {
      self remove name
      self.register(name, GaugeF(f))
    }
  }
} 

//设置package包名称以及导入依赖的类
package fr.acinq.eclair.router

import fr.acinq.eclair.TestConstants.Alice
import fr.acinq.eclair._
import fr.acinq.eclair.router.Announcements._
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.junit.JUnitRunner

import scala.compat.Platform


@RunWith(classOf[JUnitRunner])
class AnnouncementsSpec extends FunSuite {

  test("create valid signed channel announcement") {
    val (node_a, node_b, bitcoin_a, bitcoin_b) = (randomKey, randomKey, randomKey, randomKey)
    val (node_a_sig, bitcoin_a_sig) = signChannelAnnouncement(42, node_a, node_b.publicKey, bitcoin_a, bitcoin_b.publicKey, "")
    val (node_b_sig, bitcoin_b_sig) = signChannelAnnouncement(42, node_b, node_a.publicKey, bitcoin_b, bitcoin_a.publicKey, "")
    val ann = makeChannelAnnouncement(42, node_a.publicKey, node_b.publicKey, bitcoin_a.publicKey, bitcoin_b.publicKey, node_a_sig, node_b_sig, bitcoin_a_sig, bitcoin_b_sig)
    assert(checkSigs(ann))
    assert(checkSigs(ann.copy(nodeId1 = randomKey.publicKey)) === false)
  }

  test("create valid signed node announcement") {
    val ann = makeNodeAnnouncement(Alice.nodeParams.privateKey, Alice.nodeParams.alias, Alice.nodeParams.color, Alice.nodeParams.address :: Nil, Platform.currentTime / 1000)
    assert(checkSig(ann))
    assert(checkSig(ann.copy(timestamp = 153)) === false)
  }

  test("create valid signed channel update announcement") {
    val ann = makeChannelUpdate(Alice.nodeParams.privateKey, randomKey.publicKey, 45561, Alice.nodeParams.expiryDeltaBlocks, Alice.nodeParams.htlcMinimumMsat, Alice.nodeParams.feeBaseMsat, Alice.nodeParams.feeProportionalMillionth, Platform.currentTime / 1000)
    assert(checkSig(ann, Alice.nodeParams.privateKey.publicKey))
    assert(checkSig(ann, randomKey.publicKey) === false)
  }

} 

//设置package包名称以及导入依赖的类
package com.github.dnvriend

import java.util.UUID

import akka.Done
import akka.actor.ActorSystem
import akka.kafka.ProducerSettings
import akka.kafka.scaladsl.Producer
import akka.stream.ActorMaterializer
import akka.stream.scaladsl.{ Sink, Source }
import com.sksamuel.avro4s.RecordFormat
import org.apache.avro.generic.GenericRecord
import org.apache.kafka.clients.producer.ProducerRecord
import play.api.libs.json.Json

import scala.compat.Platform
import scala.concurrent.Future
import scala.util.Random

object UpdateProducer extends App {
  final case class Update(name: String, count: Int)
  object Update {
    implicit val recordFormat = RecordFormat[Update]
  }

  implicit val system = ActorSystem()
  implicit val mat = ActorMaterializer()
  implicit val ec = system.dispatcher

  val producerSettings: ProducerSettings[String, GenericRecord] = ProducerSettings[String, GenericRecord](system, None, None)
    .withBootstrapServers("localhost:9092")

  def randomId: String = UUID.randomUUID.toString

  def genericRecord[A](value: A)(implicit recordFormat: RecordFormat[A]): GenericRecord = recordFormat.to(value)

  def record[A: RecordFormat](topic: String, key: String, value: A): ProducerRecord[String, GenericRecord] =
    new ProducerRecord(topic, key, genericRecord(value))

  val sink: Sink[ProducerRecord[String, GenericRecord], Future[Done]] =
    Producer.plainSink(producerSettings)

  val done =
    Source.repeat(1)
      .take(10)
      .map(value => record("Updatess", "foo", Update("foo", 1)))
      .runWith(sink)

  val start = Platform.currentTime
  (for {
    _ <- done
    _ <- system.terminate()
  } yield println("took: " + (Platform.currentTime - start) + " millis")).recoverWith {
    case t: Throwable =>
      t.printStackTrace()
      system.terminate()
  }
}