code
stringlengths
5
1M
repo_name
stringlengths
5
109
path
stringlengths
6
208
language
stringclasses
1 value
license
stringclasses
15 values
size
int64
5
1M
enum Foo[A] { case Bar extends Foo[Int] }
som-snytt/dotty
tests/run/i6677/Enum_1.scala
Scala
apache-2.0
44
package com.codexica.s3crate.filetree.history.snapshotstore.s3 import java.io.ByteArrayInputStream import org.scalamock.specs2.MockFactory import org.jets3t.service.utils.ServiceUtils import org.apache.commons.io.FileUtils import java.util.Random import com.codexica.common.SafeLogSpecification /** * @author Josh Albrecht ([email protected]) */ class S3BlobWriterSpec extends SafeLogSpecification { trait Context extends BaseContext { val dataLength = 34985 val bytes = new Array[Byte](dataLength) new Random(1337).nextBytes(bytes) val fullDataHash = ServiceUtils.computeMD5Hash(bytes) val inputStream = new ByteArrayInputStream(bytes) } "saving a regular file" should { "create a list with one file that matches" in new Context { val (fileHashes, completeHash) = S3BlobWriter.write(inputStream, FileUtils.getTempDirectory, dataLength * 2) completeHash.toList must be equalTo fullDataHash.toList fileHashes.size must be equalTo 1 val (file, hash) = fileHashes.head FileUtils.readFileToByteArray(file).toList must be equalTo bytes.toList hash.toList must be equalTo fullDataHash.toList } } "saving a large file" should { "create a list of multiple files with matching hashes" in new Context { val secondFileSize = 2111 val firstFileSize = dataLength - secondFileSize val (fileHashes, completeHash) = S3BlobWriter.write(inputStream, FileUtils.getTempDirectory, firstFileSize) completeHash.toList must be equalTo fullDataHash.toList fileHashes.size must be equalTo 2 val (firstFile, firstHash) = fileHashes.head FileUtils.readFileToByteArray(firstFile).toList must be equalTo bytes.toList.take(firstFileSize) firstHash.toList must be equalTo ServiceUtils.computeMD5Hash(bytes.toList.take(firstFileSize).toArray).toList val (secondFile, secondHash) = fileHashes.drop(1).head FileUtils.readFileToByteArray(secondFile).toList must be equalTo bytes.toList.drop(firstFileSize) secondHash.toList must be equalTo ServiceUtils.computeMD5Hash(bytes.toList.drop(firstFileSize).toArray).toList } } }
joshalbrecht/s3crate
src/test/scala/com/codexica/s3crate/filetree/history/snapshotstore/s3/S3BlobWriterSpec.scala
Scala
mit
2,152
package snare import logger.LoggerFactory import scala.concurrent.ops.spawn import com.mongodb.{BasicDBObject, Mongo} import snare.tools.UUIDIdentitity._ import java.util.UUID import snare.tools.Implicits._ import snare.storage._ /** * The Snare main class * * @author Xavier Llora * @date Jan 25, 2010 at 7:30:48 PM * */ class Snare(val name: String, val pool: String, val metadata:BasicDBObject, val host: String, val port: Int, notify: (BasicDBObject) => Boolean) { protected val createdAt = System.currentTimeMillis protected val log = LoggerFactory.log val uuid = uniqueUUID(name) // // Main store interface object // val storage = UpdateTools(uuid,name,pool,createdAt,host,port,log) // // Basic heartbeat control of the heartbeat // private var activityFlag = false def activity = activityFlag def activity_=(stat: Boolean) = { stat match { // Need to get started case true if !this.activityFlag => { this.activityFlag = true spawnActivity } // Already running case true if this.activityFlag => // Already not running case false if !this.activityFlag => // Need to update activity to stop case false if this.activityFlag => this.activityFlag = false } this.activityFlag } // // Authentication // def authenticate(user:String,pswd:String) = storage.authenticate(user,pswd) protected val ID = new BasicDBObject ID.put("_id", uuid.toString) // The shutdown hook for this instance private val sdh = new SnareShutdownHook(this) // // The thread that runs the heart beat // protected def spawnActivity = { // // The heart beat // spawn { try { storage.registerToPool(ID, metadata) Runtime.getRuntime.addShutdownHook(sdh) log info "[HRTB] Heartbeat engaged for " + uuid while (activityFlag) { try { Thread.sleep(Snare.HEARTBEAT_INTERVAL) storage.updateHeartbeat //log finest "[HRTB] Heartbeat for " + uuid + " " + update } catch { case e => log warning "[FAIL] Heartbeat on " + uuid + " " + e.getCause } } } catch { case e => { log warning "[FAIL] Heartbeat failed to register " + uuid + " " + e.getCause activityFlag = false } } try { storage unregisterFromPool ID Runtime.getRuntime.removeShutdownHook(sdh) log info "[HRTB] Heartbeat disengaged for " + uuid } catch { case e => { log warning "[FAIL] Heartbeat failed to unregister " + uuid + " " + e.getCause activityFlag = false } } this } // // The notification threat // spawn { log info "[EVTL] Notification event loop engaged for " + uuid while (activityFlag) { try { Thread.sleep(Snare.EVENT_LOOP_INTERVAL) val cur = storage.instance.find // log finest "[EVTL] Notifications available " + cur.hasNext while (cur.hasNext) { try { val msg = cur.next.asInstanceOf[BasicDBObject] try { if (notify(msg)) log info "[EVTL] Notification processed by " + uuid + " " + msg else log info "[EVTL] Notification ignored by " + uuid + " " + msg } catch { case e => log warning "[EVTL] Exeception while processing notification on " + uuid + " " + e.toString } storage.instance.remove(msg) } catch { case e => log warning "[EVTL] Exeception while removing processed notification on " + uuid + " " + e.toString } } } catch { case e => log warning "[EVTL] Exception while pulling notifications in event loop on " + uuid + " " + e.toString } } log info "[EVTL] Notification event loop disengaged for " + uuid } } // // Returns the peers in the pool // def heartbeats = storage.queryHeartbeats def peers = storage.queryPeers def broadcast(message: BasicDBObject) = storage.queryBroadcast(message) def notifyPeer(uuid: String, message: BasicDBObject) = storage.queryNotifyPeer(uuid, message) def fetchPeerInformation (uuid:String) = storage.queryFetchPeerInformation(uuid) def fetchRegisteredPeersInformation = storage.queryFetchRegisteredPeersInformation override def toString = "<Snare: "+name+", "+pool+", "+host+", "+port+", activity="+activityFlag+">" private class SnareShutdownHook(snare: Snare) extends Thread { val log = LoggerFactory.log override def run() { log severe "Abnormal finalization. Cleaning after " + snare.uuid + ":" + snare.name storage unregisterFromPool ID log severe "Broadcasting abnormal termination of " + snare.uuid + ":" + snare.name snare.broadcast("""{"msg":"killed","type":"fatal","uuid":""" + '"' + snare.uuid + '"' + ""","ts":""" + System.currentTimeMillis + "}") } } } /** * Snare companion object * * @author Xavier Llora * @date Jan 25, 2010 at 7:30:48 PM * */ object Snare { val version = "0.4.1vcli" var HEARTBEAT_INTERVAL = 3000 var EVENT_LOOP_INTERVAL = 6000 def apply(name: String, pool: String, notify: (BasicDBObject) => Boolean) = new Snare(name, pool, new BasicDBObject, "localhost", 27017, notify) def apply(name: String, pool: String, metadata: BasicDBObject, notify: (BasicDBObject) => Boolean) = new Snare(name, pool, metadata, "localhost", 27017, notify) def apply(name: String, pool: String, metadata: BasicDBObject, port: Int, notify: (BasicDBObject) => Boolean) = new Snare(name, pool, metadata, "localhost", port, notify) def apply(name: String, pool: String, metadata: BasicDBObject, host: String, notify: (BasicDBObject) => Boolean) = new Snare(name, pool, metadata, host, 27017, notify) def apply(name: String, pool: String, metadata: BasicDBObject, host: String, port: Int, notify: (BasicDBObject) => Boolean) = new Snare(name, pool, metadata, host, port, notify) def unapply(s: Snare): Option[(UUID, String, String, BasicDBObject, String, Int, Boolean)] = Some((s.uuid, s.name, s.pool, s.metadata, s.host, s.port, s.activityFlag)) }
xllora/Snare
src/main/scala/Snare.scala
Scala
bsd-3-clause
6,395
package org.jetbrains.plugins.scala.testingSupport.scalatest.scala2_12.scalatest3_0_4 import org.jetbrains.plugins.scala.SlowTests import org.jetbrains.plugins.scala.testingSupport.scalatest.SpecialCharactersTest import org.junit.experimental.categories.Category /** * @author Roman.Shein * @since 10.03.2017 */ @Category(Array(classOf[SlowTests])) class Scalatest2_12_3_0_4_SpecialCharactersTest extends Scalatest2_12_3_0_4_Base with SpecialCharactersTest
triplequote/intellij-scala
scala/scala-impl/test/org/jetbrains/plugins/scala/testingSupport/scalatest/scala2_12/scalatest3_0_4/Scalatest2_12_3_0_4_SpecialCharactersTest.scala
Scala
apache-2.0
462
/* __ *\\ ** ________ ___ / / ___ Scala API ** ** / __/ __// _ | / / / _ | (c) 2002-2013, LAMP/EPFL ** ** __\\ \\/ /__/ __ |/ /__/ __ | http://www.scala-lang.org/ ** ** /____/\\___/_/ |_/____/_/ | | ** ** |/ ** \\* */ package scala package xml package dtd /** Parser for regexps (content models in DTD element declarations) */ object ContentModelParser extends Scanner { // a bit too permissive concerning #PCDATA import ContentModel._ /** parses the argument to a regexp */ def parse(s: String): ContentModel = { initScanner(s); contentspec } def accept(tok: Int) = { if (token != tok) { if ((tok == STAR) && (token == END)) // common mistake scala.sys.error("in DTDs, \\n" + "mixed content models must be like (#PCDATA|Name|Name|...)*") else scala.sys.error("expected " + token2string(tok) + ", got unexpected token:" + token2string(token)) } nextToken() } // s [ '+' | '*' | '?' ] def maybeSuffix(s: RegExp) = token match { case STAR => nextToken(); Star(s) case PLUS => nextToken(); Sequ(s, Star(s)) case OPT => nextToken(); Alt(Eps, s) case _ => s } // contentspec ::= EMPTY | ANY | (#PCDATA) | "(#PCDATA|"regexp) def contentspec: ContentModel = token match { case NAME => value match { case "ANY" => ANY case "EMPTY" => EMPTY case _ => scala.sys.error("expected ANY, EMPTY or '(' instead of " + value) } case LPAREN => nextToken() sOpt() if (token != TOKEN_PCDATA) ELEMENTS(regexp) else { nextToken() token match { case RPAREN => PCDATA case CHOICE => val res = MIXED(choiceRest(Eps)) sOpt() accept(RPAREN) accept(STAR) res case _ => scala.sys.error("unexpected token:" + token2string(token)) } } case _ => scala.sys.error("unexpected token:" + token2string(token)) } // sopt ::= S? def sOpt() = if (token == S) nextToken() // (' S? mixed ::= '#PCDATA' S? ')' // | '#PCDATA' (S? '|' S? atom)* S? ')*' // '(' S? regexp ::= cp S? [seqRest|choiceRest] ')' [ '+' | '*' | '?' ] def regexp: RegExp = { val p = particle sOpt() maybeSuffix(token match { case RPAREN => nextToken(); p case CHOICE => val q = choiceRest(p); accept(RPAREN); q case COMMA => val q = seqRest(p); accept(RPAREN); q }) } // seqRest ::= (',' S? cp S?)+ def seqRest(p: RegExp) = { var k = List(p) while (token == COMMA) { nextToken() sOpt() k = particle :: k sOpt() } Sequ(k.reverse: _*) } // choiceRest ::= ('|' S? cp S?)+ def choiceRest(p: RegExp) = { var k = List(p) while (token == CHOICE) { nextToken() sOpt() k = particle :: k sOpt() } Alt(k.reverse: _*) } // particle ::= '(' S? regexp // | name [ '+' | '*' | '?' ] def particle = token match { case LPAREN => nextToken(); sOpt(); regexp case NAME => val a = Letter(ElemName(value)); nextToken(); maybeSuffix(a) case _ => scala.sys.error("expected '(' or Name, got:" + token2string(token)) } // atom ::= name def atom = token match { case NAME => val a = Letter(ElemName(value)); nextToken(); a case _ => scala.sys.error("expected Name, got:" + token2string(token)) } }
som-snytt/scala-xml
src/main/scala/scala/xml/dtd/ContentModelParser.scala
Scala
bsd-3-clause
4,080
/* * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package wvlet.airframe.examples.di import wvlet.log.LogSupport /** * An example of using constructor injection. * * This pattern is useful if you do not want to include the dependency to Airframe to some classes. */ object DI_02_ConstructorInjection extends App { import wvlet.airframe._ case class MyAppConfig(port: Int = 8080) // Use Constructor Injection class MyApp(config: MyAppConfig) extends LogSupport { def run: Unit = { info(s"MyApp with ${config}") } } val d = newDesign.noLifeCycleLogging // Disable lifecycle logging // Build MyApp with Default Config d.build[MyApp] { app => app.run // port = 8080 } // Bind a custom config val d2 = d .bind[MyAppConfig].toInstance(MyAppConfig(port = 10010)) // Build MyApp with the custom config d2.build[MyApp] { app => app.run // Shows MyApp with MyAppConfig(10010) } }
wvlet/airframe
examples/src/main/scala/wvlet/airframe/examples/di/DI_02_ConstructorInjection.scala
Scala
apache-2.0
1,449
package extruder.cats import cats.data.EitherT import cats.effect.ExitCase.{Completed, Error} import cats.effect._ import cats.syntax.either._ import cats.syntax.flatMap._ import cats.syntax.functor._ import cats.{Eval, Monad, MonadError} import extruder.core.{ExtruderErrors, ValidationErrorsToThrowable} import extruder.data._ import io.estatico.newtype.macros.newsubtype import scala.util.control.NonFatal package object effect { @newsubtype case class EvalValidation[A](a: EitherT[Eval, ValidationErrors, A]) object EvalValidation extends EvalValidationLowPriorityInstances { implicit def extruderErrorsEvalValidation: ExtruderErrors[EvalValidation] = new ExtruderErrors[EvalValidation] { override def missing[A](message: String): EvalValidation[A] = EvalValidation(EitherT.leftT[Eval, A](ValidationErrors.missing(message))) override def validationFailure[A](message: String): EvalValidation[A] = EvalValidation(EitherT.leftT[Eval, A](ValidationErrors.failure(message))) override def validationException[A](message: String, ex: Throwable): EvalValidation[A] = EvalValidation(EitherT.leftT[Eval, A](ValidationErrors.exception(message, ex))) override def fallback[A](fa: EvalValidation[A])(thunk: => EvalValidation[A]): EvalValidation[A] = EvalValidation( EitherT( fa.a.value .flatMap( _.fold(errs => Eval.later(thunk.a.value.value.leftMap(_ ++ errs.toList)), a => Eval.later(Right(a))) ) ) ) } } trait EvalValidationLowPriorityInstances { implicit def extruderStdInstancesForEvalValidation( implicit toThrowable: ValidationErrorsToThrowable ): Sync[EvalValidation] = new Sync[EvalValidation] { def F: MonadError[ValidationT[Eval, ?], Throwable] = MonadError[ValidationT[Eval, ?], Throwable] def FF: Monad[EitherT[Eval, ValidationErrors, ?]] = Monad[EitherT[Eval, ValidationErrors, ?]] override def suspend[A](thunk: => EvalValidation[A]): EvalValidation[A] = EvalValidation(EitherT(Eval.later(try { thunk.a.value.value } catch { case NonFatal(th) => Left(ValidationErrors.exception(th)) }))) override def delay[A](thunk: => A): EvalValidation[A] = EvalValidation(EitherT[Eval, ValidationErrors, A](Eval.always(try { Right(thunk) } catch { case NonFatal(th) => Left(ValidationErrors.exception(th)) }))) override def bracketCase[A, B]( acquire: EvalValidation[A] )(use: A => EvalValidation[B])(release: (A, ExitCase[Throwable]) => EvalValidation[Unit]): EvalValidation[B] = acquire.a.value.value match { case Right(a) => val res = use(a) res.a.value.value match { case Right(b) => EvalValidation(release(a, Completed).a.map(_ => b)) case Left(errs) => release(a, Error(toThrowable.convertErrors(errs))).a.value.value match { case Right(_) => res case Left(_) => res } } case e @ Left(_) => EvalValidation(EitherT(Eval.now(e.rightCast[B]))) } override def raiseError[A](e: Throwable): EvalValidation[A] = EvalValidation(F.raiseError(e).a) override def handleErrorWith[A](fa: EvalValidation[A])(f: Throwable => EvalValidation[A]): EvalValidation[A] = EvalValidation(F.handleErrorWith(ValidationT(fa.a))(f.andThen(a => ValidationT(a.a))).a) override def pure[A](x: A): EvalValidation[A] = EvalValidation(FF.pure(x)) override def flatMap[A, B](fa: EvalValidation[A])(f: A => EvalValidation[B]): EvalValidation[B] = EvalValidation(FF.flatMap(fa.a)(f.andThen(_.a))) override def tailRecM[A, B](a: A)(f: A => EvalValidation[Either[A, B]]): EvalValidation[B] = EvalValidation(FF.tailRecM(a)(f.andThen(_.a))) override def ap[A, B](ff: EvalValidation[A => B])(fa: EvalValidation[A]): EvalValidation[B] = EvalValidation(F.ap(ValidationT(ff.a))(ValidationT(fa.a)).a) override def ap2[A, B, Z]( ff: EvalValidation[(A, B) => Z] )(fa: EvalValidation[A], fb: EvalValidation[B]): EvalValidation[Z] = EvalValidation(F.ap2(ValidationT(ff.a))(ValidationT(fa.a), ValidationT(fb.a)).a) } } @newsubtype case class EffectValidation[F[_], A](a: EitherT[F, ValidationErrors, A]) object EffectValidation extends TimerInstances with ContextShiftInstances with ConcurrentEffectInstances { implicit def extruderErrorsEffectValidation[F[_]]( implicit F: MonadError[F, Throwable] ): ExtruderErrors[EffectValidation[F, ?]] = new ExtruderErrors[EffectValidation[F, ?]] { override def missing[A](message: String): EffectValidation[F, A] = EffectValidation(EitherT.leftT[F, A](ValidationErrors.missing(message))) override def validationFailure[A](message: String): EffectValidation[F, A] = EffectValidation(EitherT.leftT[F, A](ValidationErrors.failure(message))) override def validationException[A](message: String, ex: Throwable): EffectValidation[F, A] = EffectValidation(EitherT.leftT[F, A](ValidationErrors.exception(message, ex))) override def fallback[A](fa: EffectValidation[F, A])(thunk: => EffectValidation[F, A]): EffectValidation[F, A] = EffectValidation( EitherT( fa.a.value.flatMap(_.fold(errs => thunk.a.value.map(_.leftMap(_ ++ errs.toList)), a => F.pure(Right(a)))) ) ) } } }
janstenpickle/extruder
cats-effect/src/main/scala/extruder/cats/effect/package.scala
Scala
mit
5,612
package com.cds.learnscala.extractors object PatternMatch { case class User(firstName: String, lastName: String, score: Int) def advance(xs: List[User]) = xs match { case User(_, _, score1) :: User(_, _, score2) :: _ => score1 - score2 case _ => 0 } def main(args: Array[String]) { } }
anancds/scala-project
learn-scala/src/main/scala/com/cds/learnscala/extractors/PatternMatch.scala
Scala
mit
310
package uk.gov.gds.ier.transaction.shared /** * Variant of Scala Either class tailored for Mustache limitations, specifically confirmation page. * * Mustache conditions work well only with Options or booleans, not Either; Mustache cannot * interpret properly LeftProjection/RightProjection used internally by Either. */ case class EitherErrorOrContent(blockContent: Option[List[String]], blockError: Option[String]) /** instantiate positive variant of EitherErrorOrContent */ object BlockContent { def apply(values: List[String]) = EitherErrorOrContent(blockContent = Some(values), blockError = None) def apply(value: String) = EitherErrorOrContent(blockContent = Some(List(value)), blockError = None) } /** instantiate negative variant of EitherErrorOrContent */ object BlockError { def apply(value: String) = EitherErrorOrContent(blockContent = None, blockError = Some(value)) }
michaeldfallen/ier-frontend
app/uk/gov/gds/ier/transaction/shared/ConfirmationMustacheCommon.scala
Scala
mit
896
/* * Copyright 2016 The BigDL Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.intel.analytics.bigdl.dllib.utils.tf.loaders import java.nio.ByteOrder import com.intel.analytics.bigdl.Module import com.intel.analytics.bigdl.dllib.nn.tf.{DecodeRaw => DecodeRawOp} import com.intel.analytics.bigdl.dllib.tensor.TensorNumericMath.TensorNumeric import com.intel.analytics.bigdl.dllib.utils.tf.Context import org.tensorflow.framework.NodeDef import scala.reflect.ClassTag class DecodeRaw extends TensorflowOpsLoader { import Utils._ override def build[T: ClassTag](nodeDef: NodeDef, byteOrder: ByteOrder , context: Context[T])(implicit ev: TensorNumeric[T]): Module[T] = { val attrs = nodeDef.getAttrMap val endian = getBoolean(attrs, "little_endian") val outType = attrs.get("out_type").getType new DecodeRawOp[T](outType, endian) } }
intel-analytics/BigDL
scala/dllib/src/main/scala/com/intel/analytics/bigdl/dllib/utils/tf/loaders/DecodeRaw.scala
Scala
apache-2.0
1,399
package org.eigengo.sbtmdrw import java.io.File import org.pegdown.{LinkRenderer, ToHtmlSerializer, Extensions, PegDownProcessor} import scala.io.Source import sbt.{Logger, State} import scala.util.Try class MarkdownRewriter(source: File, renderer: MarkdownRenderer) { val sourceCharacters = Source.fromFile(source).iter.toArray def run[A](log: Logger)(onComplete: Try[String] => A): A = { val processor = new PegDownProcessor(Extensions.FENCED_CODE_BLOCKS | Extensions.HARDWRAPS | Extensions.TABLES | Extensions.DEFINITIONS) val root = processor.parseMarkdown(sourceCharacters) renderer.render(root, log)(onComplete) } }
eigengo/sbt-mdrw
src/main/scala/org/eigengo/sbtmdrw/MarkdownRewriter.scala
Scala
apache-2.0
645
package org.nexbook.performance.app import com.typesafe.config.Config import org.nexbook.app.{AppConfig, OrderBookApp} import org.nexbook.fix.FixMessageHandler import org.nexbook.performance.PerformanceTest import org.nexbook.performance.result.ResultLogger import org.nexbook.testutils.FixMessageProvider import org.slf4j.Logger import quickfix.{Message, SessionID} /** * Created by milczu on 08.01.16. */ trait OrderBookAppPerformanceTest extends PerformanceTest { val appRoot = ScriptRunner.executeScript("app-root.sh") val resultLogger = new ResultLogger val dbCollections = List("orders", "executions") def cleanBeforeTest(): Unit = dbCollections.foreach(MongodbTestUtils.dropCollection) def logger: Logger def benchmarkConfig: Config def testDataPath: String def resultLog: String def expectedTotalOrdersCount: Int val fixMessageApplierThreadPool = 64 def executeTest() = { logger.info("Test run!") logger.debug("Load all FIX messages for test") val messages: List[(Message, SessionID)] = FixMessageProvider.get(testDataPath) logger.debug("FIX messages for test loaded") cleanBeforeTest() asyncExecute("OrderBookApp") { OrderBookApp.main(Array()) } applyFixMessages(messages, OrderBookApp.fixMessageHandler) new AppProgressChecker().execute() resultLogger.logResultToFile(benchmarkConfig, resultLog, writeHeader = true) OrderBookApp.stop() } def applyFixMessages(messages: List[(Message, SessionID)], fixMessageHandler: FixMessageHandler) = { if (fixMessageApplierThreadPool == 1) { asyncExecute("Async FIX message applier") { logger.info("Apply FIX messages") messages.foreach(m => fixMessageHandler.fromApp(m._1, m._2)) logger.info("Applied FIX messages") } } else { val partitionSize = math.ceil(messages.size / fixMessageApplierThreadPool.toDouble).toInt val messagesPartitions: List[List[(Message, SessionID)]] = messages.grouped(partitionSize).toList for (part <- messagesPartitions.indices) { asyncExecute(s"Async FIX message applier: $part") { logger.info("Apply FIX messages") messagesPartitions(part).foreach { m => fixMessageHandler.fromApp(m._1, m._2)/*; if(Random.nextInt(10) % 3 == 0) Thread.sleep(0,5) else Thread.sleep(0)*/ } logger.info(s"Applied FIX messages: $part") } } } } class AppProgressChecker { val scriptsPath = "src/test/resources/scripts" val logFile = "nexbook.log" import sys.process._ val phraseFMH = "FixMessageHandler - .* - onMessage:" val phraseME = "MatchingEngine - .* - Order processed" val phraseTDS = "TradeDatabaseSaver - .* - Saved order" def execute() = { Thread.sleep(20000) while (!isAppFinished) { val countTDS = MongodbTestUtils.count("orders") val countME = countOccurrencesInLogFile(phraseME) val countFMH = countOccurrencesInLogFile(phraseFMH) logger.info(s"Current counts - FMH: $countFMH, ME: $countME, TDS: $countTDS") Thread.sleep(10000) } logger.info("Progress checker finished") val startLine = findFirstOccurrenceInLogFile(phraseFMH) val endLine = findLastOccurrenceInLogFile(phraseME) def extractNanoTimeFromLogFile(line: String): Long = line.split(" ")(1).toLong val startTime = extractNanoTimeFromLogFile(startLine) val endTime = extractNanoTimeFromLogFile(endLine) import scala.concurrent.duration._ val execTime = Duration(endTime - startTime, NANOSECONDS) val throughput = (expectedTotalOrdersCount / execTime.toMicros.toDouble * Duration(1, SECONDS).toMicros).toInt logger.info(s"Duration: ${execTime.toMillis}ms. Throughput: $throughput orders/s") } def isAppFinished: Boolean = { logger.info("executing isAppFinished") def allOrdersProcessedInFixMessageHandler: Boolean = countOccurrencesInLogFile(phraseFMH) == expectedTotalOrdersCount def allOrdersHandlerInMatchingEngine: Boolean = countOccurrencesInLogFile(phraseME) == expectedTotalOrdersCount def allOrdersSavedInDb: Boolean = !AppConfig.dbPersist || MongodbTestUtils.count("orders") == expectedTotalOrdersCount def appFinishedConditions: List[Boolean] = List(allOrdersProcessedInFixMessageHandler, allOrdersHandlerInMatchingEngine, allOrdersSavedInDb) // List(allOrdersProcessedInFixMessageHandler, allOrdersHandlerInMatchingEngine, allOrdersSavedInDb) appFinishedConditions.reduce(_ && _) } def countOccurrencesInLogFile(phrase: String): Int = { val cmd = s"cp $appRoot/logs/$logFile $appRoot/logs/temp.log && less $appRoot/logs/temp.log | grep '$phrase' | wc -l" val output = (stringSeqToProcess(Seq("bash", "-c", cmd)) !!).trim (stringSeqToProcess(Seq("bash", "-c", s"rm -rf $appRoot/logs/temp.log")) !) if (!output.matches("\\\\d+")) { logger.warn(s"returned output: $output for $phrase") 0 } else output.toInt } def findFirstOccurrenceInLogFile(phrase: String): String = { val cmd = s"less $appRoot/logs/$logFile | grep '$phrase' | head -n 1" (stringSeqToProcess(Seq("bash", "-c", cmd)) !!).trim } def findLastOccurrenceInLogFile(phrase: String): String = { val cmd = s"less $appRoot/logs/$logFile | grep '$phrase' | tail -n 1" (stringSeqToProcess(Seq("bash", "-c", cmd)) !!).trim } } }
milczarekIT/nexbook
src/test/scala/org/nexbook/performance/app/OrderBookAppPerformanceTest.scala
Scala
apache-2.0
5,158
package com.dongxiguo.zeroLog.context import language.experimental.macros final class CurrentLine (val get: Int) extends AnyVal object CurrentLine { final def currentLine_impl(c: scala.reflect.macros.Context) = { import c.universe._ val lineExpr = c.Expr(Literal(Constant(c.enclosingPosition.line))) reify(new _root_.com.dongxiguo.zeroLog.context.CurrentLine(lineExpr.splice)) } implicit final def currentLine: CurrentLine = macro currentLine_impl }
jasoncao/zero-log
context/src/main/scala/com/dongxiguo/zeroLog/context/CurrentLine.scala
Scala
apache-2.0
473
package synthesis // dummy object APAInputSyntaxTree /** Provides several methods to deal with input terms. * * @author Mikaël Mayer */ object APAInputTerm { def partitionInteger(l: List[APAInputTerm]): (List[Int], List[APAInputTerm]) = l match { case Nil => (Nil, Nil) case (APAInputCombination(n, Nil)::q) => val (a, b) = partitionInteger(q) (n::a, b) case (p::q) => val (a, b) = partitionInteger(q) (a, p::b) } } /***************** * Input terms * *****************/ /** Trait expressing that an expression can be converted to an InputTerm * It is useful to deal with Input variables, which are not directly InputTerms * in order not to overload the pattern matching. * * @author Mikaël Mayer */ trait ConvertibleToInputTerm { implicit def toInputTerm():APAInputTerm } /** A class defining a general input term, that is, containing only input variables and integers. * A sign abstraction is provided for each term. * * @author Mikaël Mayer */ sealed abstract class APAInputTerm extends SignAbstraction { /** Returns the same expression, but simplified. */ def simplified:APAInputTerm // OptimizeMe : Store when it's already simplified in order not to compute two times the same thing /** @return The list of Input variables that this expression contains. */ def input_variables: List[InputVar] //@{ Operators /** @param that A combination eventually containing output variables. */ /** @return The sum of this input term and the provided APACombination. */ def +(that : APACombination):APACombination = that + APACombination(this) /** @return The difference of this input term and the provided APACombination. */ def -(that : APACombination):APACombination = -that + APACombination(this) /** @return The product of this input term and the provided APACombination. */ def *(that : APACombination):APACombination = that * this /** @return The sum of this input term and the provided input term. */ def +(that : APAInputTerm): APAInputTerm = APAInputAddition(this, that).simplified /** @return The division of this input term by the provided input term. */ def /(that : APAInputTerm): APAInputTerm = APAInputDivision(this, that).simplified /** @return The product of this input term by the provided input term. */ def *(that : APAInputTerm): APAInputTerm = APAInputMultiplication(this, that).simplified /** @return The difference between this input term and the provided one. */ def -(that : APAInputTerm): APAInputTerm = (this, that) match { case (t1: APAInputCombination, t2: APAInputCombination) => t1 - t2 case _ => this+(that*APAInputCombination(-1)) } /** @return The opposite of this input term. */ def unary_-(): APAInputTerm = APAInputCombination(0, Nil) - this //@} /** @return This input term where all occurences of y have been replaced by t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm /** @return This input term where all occurences of y have been replaced by t. */ def replaceList(lxt : List[(InputVar, APAInputTerm)]): APAInputTerm = { lxt.foldLeft(this){ case (result, (x, t)) => result.replace(x, t) } } /** @return This input term where the sign abstraction s is applied to all occurences of t1 */ def assumeSignInputTerm(t1: APAInputTerm, s: SignAbstraction):APAInputTerm = { (this, t1, -t1) match { case (t0:APAInputCombination, t1:APAInputCombination, _) if t0 == t1 => val result = t1.assumeSign(s).propagateSign(this) result case (t0:APAInputCombination, _, mt1:APAInputCombination) if t0 == mt1 => val result = (-t1.assumeSign(s)).propagateSign(this) result case (t0:APAInputCombination, t1:APAInputCombination, mt1:APAInputCombination) => this case _ => this } } /** @return The integer that this input term represents if it exists, else throws an exception. */ def toInt: Int = this match { case APAInputCombination(i, Nil) => i case _ => throw new Exception(this + " cannot be converted to an integer") } /** Converts this input term to a string */ override def toString = toGeneralString /** Converts this input term to a string in the current rendering mode */ /** See APASynthesis.rendering_mode. */ def toGeneralString: String = APASynthesis.rendering_mode match { case rm@RenderingPython() => toPythonString(rm) case rm@RenderingScala() => toScalaString(rm) } /** Converts this input term to a Python string. */ /** @rm should be a RenderingPython() */ protected def toPythonString(rm: RenderingMode): String = this match { case APAInputLCM(l) => rm.lcm_symbol+"(["+(l map (_.toCommonString(rm)) reduceLeft (_ + "," + _)) +"])" case APAInputGCD(l) => rm.gcd_symbol+"(["+(l map (_.toCommonString(rm)) reduceLeft (_ + "," + _)) +"])" case _ => toCommonString(rm) } /** Converts this input term to a Scala string. */ /** @rm should be a RenderingScala() */ protected def toScalaString(rm: RenderingMode): String = this match { case APAInputLCM(l) => rm.lcm_symbol+"(List("+(l map (_.toCommonString(rm)) reduceLeft (_ + "," + _)) +"))" case APAInputGCD(l) => rm.gcd_symbol+"(List("+(l map (_.toCommonString(rm)) reduceLeft (_ + "," + _)) +"))" case _ => toCommonString(rm) } /** Converts this input term to a common string in the provided rendering mode. */ /** rm should be equal to APASynthesis.rendering_mode */ def toCommonString(rm:RenderingMode):String = this match { case APAInputMultiplication(Nil) => "1" case APAInputMultiplication(a::Nil) => a.toCommonString(rm) case APAInputMultiplication(l) => l map { case el => val s = el.toCommonString(rm) if(((s indexOf '-') >= 0) || ((s indexOf '+') >= 0) || ((s indexOf '/') >= 0)) "("+s+")" else s } reduceLeft (_ + "*" + _) case APAInputDivision(Nil, ld) => "1/("+APAInputMultiplication(ld).toCommonString(rm)+")" case APAInputDivision(ln, Nil) => APAInputMultiplication(ln).toCommonString(rm) case APAInputDivision(ln, ld) => val num = APAInputMultiplication(ln).toCommonString(rm) val den = APAInputMultiplication(ld).toCommonString(rm) val num_string = (if((num indexOf '+') >= 0 || (num indexOf '-') >= 0 || (num indexOf '+') >= 0) "("+num+")" else num ) val den_string = (if((den indexOf '+') >= 0 || (den indexOf '-') >= 0 || (den indexOf '+') >= 0) "("+den+")" else den ) num_string +"/"+den_string case APAInputAddition(l) => l map { case el => val s = el.toCommonString(rm) if((s indexOf '-') >= 0) "("+s+")" else s } reduceLeft (_ + " + " + _) case APAInputAbs(e) => rm.abs_symbol + "("+e.toCommonString(rm)+")" case APAInputLCM(Nil) => throw new Exception("What is this lcm that has not been simplified ??") case APAInputLCM(l) => rm.lcm_symbol+"(List("+(l map (_.toCommonString(rm)) reduceLeft (_ + "," + _)) +"))" case APAInputGCD(l) => rm.gcd_symbol+"(List("+(l map (_.toCommonString(rm)) reduceLeft (_ + "," + _)) +"))" case t:APAInputCombination => t.toNiceString /*case APAInputMod(operand, divisor) => val num = operand.toCommonString(rm) val den = operand.toCommonString(rm) val num_string = (if((num indexOf '+') >= 0 || (num indexOf '-') >= 0 || (num indexOf '+') >= 0) "("+num+")" else num ) val den_string = (if((den indexOf '+') >= 0 || (den indexOf '-') >= 0 || (den indexOf '+') >= 0) "("+den+")" else den ) val final_den_string = if(divisor.isPositive) den_string else (rm.abs_symbol+"("+den_string+")") rm.mod_function(num_string, final_den_string)*/ //case _ => super.toString } } /** Definition of an input variable. */ case class InputVar(name: String) extends SignAbstraction with ConvertibleToInputTerm with APAVariable { /** Clones the variable without the sign abstraction */ def normalClone():this.type = InputVar(name).asInstanceOf[this.type] /** Return an InputTerm containing the variable. */ def toInputTerm():APAInputCombination = { if(isZero) return APAInputCombination(0) APAInputCombination(this) } // Syntactic sugar //def +(pac : APACombination) = pac+APACombination(this) //def +(v : InputVar) = APACombination(v)+APACombination(this) //def +(v : OutputVar) = APACombination(v)+APACombination(this) //def *(i : Int) = APAInputCombination(0, (i, this)::Nil) //def *(that: APAInputTerm) = APAInputMultiplication(APAInputCombination(this), that) } /** Object to provide more constructors for APAInputCombination. */ object APAInputCombination { def apply(i: Int):APAInputCombination = APAInputCombination(i, Nil) def apply(i: InputVar):APAInputCombination = APAInputCombination(0, (1, i)::Nil).propagateSign(i) } /** A linear combination of input variables, with a constant coefficient. */ case class APAInputCombination(coefficient: Int, input_linear: List[(Int, InputVar)]) extends APAInputTerm { setSign(SignAbstraction.linearCombinationSign(coefficient, input_linear)) /** Clones the expression without the sign abstraction. */ def normalClone():this.type = APAInputCombination(coefficient, input_linear).asInstanceOf[this.type] /** Returns the list of input variables that this expression contains. */ def input_variables: List[InputVar] = input_linear map (_._2) /** Returns true if the variable i1 is has a name lexicographically less than the variable i2. */ def by_InputVar_name(i1:(Int, InputVar), i2:(Int, InputVar)) : Boolean = (i1, i2) match { case ((_, InputVar(name1)), (_, InputVar(name2))) => name1 < name2 } /** Adds the coefficiented variable i to the list of existing coefficiented regrouped_vars. */ /** Assumes that if the variable appears exist, it appears first. */ def fold_Inputvar_name(i:(Int, InputVar), regrouped_vars:List[(Int, InputVar)]):List[(Int, InputVar)] = (i, regrouped_vars) match { case (i, Nil) => i::Nil case ((coef1, InputVar(name1)), (coef2, InputVar(name2))::q) if name1 == name2 => (coef1 + coef2, InputVar(name1))::q case (i, q) => i::q } /** Intercepts the sign propagation, and if there is a unique variable, propagates the sign abstraction to it. */ override def propagateSign(s: SignAbstraction):this.type = { //Intercepts the sign propagation val result = (coefficient, input_linear) match { case (0, (i, v)::Nil) => val new_v = v.assumeSign(SignAbstraction.multSign(SignAbstraction.mergeSign(this, s), SignAbstraction.number(i))) APAInputCombination(0, (i, new_v)::Nil) case _ => this } result.propagateSign_internal(s).asInstanceOf[this.type] } /** Returns a simplified version of this input combination. * Guarantees that * - The variables are alphabetically sorted, * - There are no null coefficients */ def simplified: APAInputCombination = { if(isZero) return APAInputCombination(0) val input_linear2 = (input_linear sortWith by_InputVar_name ).foldRight[List[(Int, InputVar)]](Nil){ case (a, b) => fold_Inputvar_name(a, b)} val input_linear3: List[(Int, InputVar)] = input_linear2 match { case (i, v)::Nil => (i, v.assumeSign(SignAbstraction.multSign(this, SignAbstraction.number(i))))::Nil case _ => input_linear2 } APAInputCombination(coefficient, input_linear3 remove { case (i, v) => i == 0 || v.isZero}).propagateSign(this) } /** Returns the list of the coefficients in front of the input variables + the constant coefficient. */ def coefficient_list = (coefficient :: ((input_linear map (_._1)) )) /** Returns true if there is a non-null coefficient in the combination. */ def has_gcd_coefs: Boolean = coefficient_list exists (_ != 0) /** Returns the gcd of all coefficients. <code>has_gcd_coefs</code> is assumed. */ def gcd_coefs = Common.gcdlist(coefficient_list) /** Returns the first sign present. * If this sign is negative in equations like -a+b == 0, * it is used to gain a character and produce a-b == 0 */ def first_sign_present = coefficient_list find (_ != 0) match { case Some(i) => if(i > 0) 1 else -1 case None => 1 } /** Returns the division of this combination by an integer. */ /** Needs the coefficients to be divisible by i. */ def /(i : Int): APAInputCombination = { APAInputCombination(coefficient / i, input_linear map {t => (t._1 / i, t._2)}).assumeSign(SignAbstraction.multSign(this, SignAbstraction.number(i))) } /** Returns true if this combination can be safely divisible by i. */ def safelyDivisibleBy(i : Int): Boolean = { coefficient % i == 0 && (input_linear forall { case (k, v) => k % i == 0}) } /** Returns the division of an input combination by another. */ /** The result is not necessarily a input combination */ def /(that : APAInputCombination): APAInputTerm = { APAInputDivision(this, that).simplified } /** Returns the multiplication of this input combination by an integer. */ def *(i : Int): APAInputCombination = { APAInputCombination(coefficient * i, input_linear map {t => (t._1 * i, t._2)}).assumeSign(SignAbstraction.multSign(this, SignAbstraction.number(i))) } /** Returns the multiplication of this input combination by another input combination. */ /** The result is not necessarily a input combination */ def *(that : APAInputCombination): APAInputTerm = { APAInputMultiplication(this, that).simplified } /** Returns the sum of two input combinations. */ def +(pac : APAInputCombination): APAInputCombination = pac match { case APAInputCombination(c, i) => APAInputCombination(coefficient + c, input_linear ++ i).simplified.assumeSign(SignAbstraction.addSign(this, pac)) } /** Returns the difference between two input combinations. */ def -(that : APAInputCombination): APAInputCombination = this + (that * (-1)) /** Returns the sum of this input combination with a coefficiented variable. */ def +(kv : (Int, InputVar)): APAInputCombination = this + APAInputCombination(0, kv::Nil) /** Returns the sum of this input combination with an integer. */ def +(k : Int): APAInputCombination = this + APAInputCombination(k, Nil) /** Returns the difference of this input combination with a coefficiented variable. */ def -(kv : (Int, InputVar)): APAInputCombination = this - APAInputCombination(0, kv::Nil) /** Returns the difference of this input combination with an integer. */ def -(k : Int): APAInputCombination = this + APAInputCombination(-k, Nil) /** Returns the opposite of this input combination. */ override def unary_-(): APAInputCombination = (APAInputCombination(0, Nil) - this).propagateSign(SignAbstraction.oppSign(this)) /** Returns the linear expression where the input variable y has been replaced by the expression t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { val (input_linear_with_y, input_linear_without_y) = input_linear partition (_._2 == y) val pac_without_y = APAInputCombination(coefficient, input_linear_without_y) val total_y_coefficient = (input_linear_with_y map (_._1)).foldLeft(0)(_+_) val result = t match { case t:APAInputCombination => pac_without_y + (t*total_y_coefficient) case _ => APAInputAddition(pac_without_y, APAInputMultiplication(APAInputCombination(total_y_coefficient), t)) } result.propagateSign(this) } /** Returns this expression where the fact that t1 has sign s has been taken into account. */ override def assumeSignInputTerm(t1: APAInputTerm, s: SignAbstraction) = { t1 match { case t@APAInputCombination(coefficient2, Nil) => this // Would be strange to arrive there. case t@APAInputCombination(coefficient2, (i, v)::l) => // i is not null, input_linear find (_._2 == v) match { case Some((i2, v2)) => val t_assumed = t.assumeSign(s) val resultWithoutT = (this*i-t_assumed*i2) val resultAddingT =(t_assumed*i2) val resultMultipliedByI = resultWithoutT+resultAddingT val result = resultMultipliedByI/i result case None => this // This variable is not there, so we cannot conclude anything. } case _ => this } } /** Returns a string representing this linear combination. */ override def toString = toNiceString // Comment this to keep the abstract syntax tree representation /** Returns a nice string representing an usual linear combination, e.g. like 5+3a. */ def toNiceString:String = { def inputElementToString(kv : (Int, InputVar)) = kv._1 match { case 1 => kv._2.name case -1 => "-" + kv._2.name case k => k + "*" + kv._2.name } def makePlus(l: List[String]):String = l match { case Nil => "" case a::p => val s = makePlus(p) if(s=="") a else if(a=="") s else if(s.charAt(0) == '-') a + s else a + "+" + s } var c_string = if(coefficient == 0) "" else coefficient.toString var i_string = input_linear match { case Nil => "" case a::l => l.foldLeft(inputElementToString(a)) { (s, t2) => val t2s = inputElementToString(t2) s + (if(t2s.charAt(0) =='-') t2s else "+" + t2s)} } val s = makePlus(c_string::i_string::Nil) if(s == "") "0" else s } } /** Object providing methods to create a division of input terms, with some optimizations. */ object APAInputDivision { /** Returns a simplified division of input terms. */ def apply(a: APAInputTerm, b: APAInputTerm): APAInputTerm = APAInputDivision(a::Nil, b::Nil).simplified /** Returns a division where common occurences between n and d have been removed (simplification). */ def simplifyNumDenom(n: List[APAInputTerm], d:List[APAInputTerm]):APAInputTerm = { val (to_delete, n_ok) = n partition (d contains _) if(to_delete != Nil) { val (d_updated, to_be_nil) = d.foldLeft((to_delete, Nil:List[APAInputTerm])){ case ((to_delete, collecter), el) => if(to_delete contains el) (to_delete - el, collecter) else (to_delete, collecter ++ (el ::Nil)) } APAInputDivision(n_ok, d_updated) } else { APAInputDivision(n, d) } } } /** Class representing a integer division between input terms. * It should be guaranteed that the denominator divides the numerator. */ case class APAInputDivision(numerator: List[APAInputTerm], denominator : List[APAInputTerm]) extends APAInputTerm { setSign(SignAbstraction.divSign(SignAbstraction.multSign(numerator), SignAbstraction.multSign(denominator))) /** Returns a clone of this expression without the sign abstraction. */ def normalClone():this.type = APAInputDivision(numerator, denominator).asInstanceOf[this.type] /** Returns a simplified version of this division. */ def simplified:APAInputTerm = { if(isZero) return APAInputCombination(0) val result = ((APAInputMultiplication(numerator).simplified, APAInputMultiplication(denominator).simplified) match { case (n, APAInputCombination(1, Nil)) => n case (n, d) if n == d => APAInputCombination(1, Nil) case (nm@APAInputMultiplication(n), dm@APAInputMultiplication(d)) => APAInputDivision.simplifyNumDenom(n, d) case (nm, dm@APAInputMultiplication(d)) => APAInputDivision.simplifyNumDenom(nm::Nil, d) case (nm@APAInputMultiplication(n), dm) => APAInputDivision.simplifyNumDenom(n, dm::Nil) case (nc@APAInputCombination(c, Nil), dc@APAInputCombination(i, Nil)) => APAInputCombination(c/i) case (nc@APAInputCombination(c, l), dc@APAInputCombination(i, Nil)) if nc.safelyDivisibleBy(i) => nc/i case (nc@APAInputCombination(c, l), dc@APAInputCombination(i, Nil)) => APAInputDivision(nc::Nil, dc::Nil) case (n, d) => APAInputDivision(n::Nil, d::Nil) }) result.propagateSign(this) } /** Returns the division where the variable y has been replaced by the input term t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { APAInputDivision(numerator map (_.replace(y, t)), denominator map (_.replace(y, t))).simplified.propagateSign(this) } /** Returns the list of input variables that this division contains. */ def input_variables: List[InputVar] = { ((numerator flatMap (_.input_variables)) ++ (denominator flatMap (_.input_variables))).distinct } } /** Object providing a method to create multiplications of input terms. */ object APAInputMultiplication { def apply(a: APAInputTerm*):APAInputTerm = APAInputMultiplication(a.toList).simplified } /** Class representing a multiplication between input terms. */ case class APAInputMultiplication(operands: List[APAInputTerm]) extends APAInputTerm { //assert(operands.length > 1) // Else it does not make sense, it should have been simplified. setSign(SignAbstraction.multSign(operands)) /** Returns a clone of this multiplication without the sign abstraction. */ def normalClone():this.type = APAInputMultiplication(operands).asInstanceOf[this.type] /** Returns a simplified equal version of this multiplication. */ def simplified:APAInputTerm = { if(isZero) return APAInputCombination(0) val result = operands flatMap (_.simplified match { case APAInputMultiplication(l) => l map (_.assumeNotzerobility(this)) case APAInputCombination(1, Nil) => Nil case t => List(t.assumeNotzerobility(this)) }) match { case Nil => APAInputCombination(1, Nil) case a::Nil => a case l => APAInputTerm.partitionInteger(l) match { case (Nil, l) => APAInputMultiplication(l) case (integers, not_input_combinations) => ((integers reduceLeft (_ * _)), not_input_combinations) match { case (0, _) => APAInputCombination(0) case (a, Nil) => APAInputCombination(a) case (a, (t:APAInputCombination)::q) => APAInputMultiplication((t*a)::q) case (a, _) => val s = APAInputCombination(a)::not_input_combinations APAInputMultiplication(s) } } } result.propagateSign(this) } /** Returns the same multiplication where the non-zerobility of the applied sign abstraction. */ /** is propagated to all sub-children. */ override def propagateSign(s: SignAbstraction):this.type = { //Intercepts the sign propagation if(s.isNotZero) { val new_operands = operands map (_.assumeNotzerobility(s)) APAInputMultiplication(new_operands).propagateSign_internal(s).asInstanceOf[this.type] } else { APAInputMultiplication(operands).propagateSign_internal(s).asInstanceOf[this.type] } } /** Returns an expression where all occurences of the variable y have been replaced by t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { APAInputMultiplication(operands map (_.replace(y, t))).propagateSign(this).simplified } /** Returns the list of input variables contained in this multiplication. */ def input_variables: List[InputVar] = { (operands flatMap (_.input_variables)).distinct } } /** Object providing a method to create additions of input terms and others. */ object APAInputAddition { /** Returns an addition of the given input terms. */ def apply(a: APAInputTerm*):APAInputTerm = APAInputAddition(a.toList).simplified /** Separate the input terms in l between input combinations and general input terms. */ /** Used to group input combinations together */ def partitionInputCombination(l: List[APAInputTerm]): (List[APAInputCombination], List[APAInputTerm]) = l match { case Nil => (Nil, Nil) case ((t@APAInputCombination(_, _))::q) => val (a, b) = partitionInputCombination(q) (t::a, b) case (p::q) => val (a, b) = partitionInputCombination(q) (a, p::b) } } /** Class representing an addition of given input terms. * Additions differs from linear combinations, because they can store general additions * like a*b+c+b^2+1 */ case class APAInputAddition(l: List[APAInputTerm]) extends APAInputTerm { setSign(SignAbstraction.addSign(l)) /** Returns a clone of this addition without the top-level abstraction (strange ?). */ def normalClone():this.type = APAInputAddition(l).asInstanceOf[this.type] /** Returns a simplified version of this addition. */ def simplified:APAInputTerm = { if(isZero) return APAInputCombination(0) val result = l flatMap (_.simplified match { case APAInputAddition(l) => l case APAInputCombination(0, Nil) => Nil case t => List(t) }) match { case Nil => APAInputCombination(0, Nil) case a::Nil => a case l => APAInputAddition.partitionInputCombination(l) match { case (Nil, l) => APAInputAddition(l) case (input_combinations, not_input_combinations) => ((input_combinations reduceLeft (_ + _)), not_input_combinations) match { case (a, Nil) => a case (a, _) => val s = a::not_input_combinations APAInputAddition(s) } } } result.propagateSign(this) } /** Returns an expression where all occurences of the variable y have been replaced by t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { APAInputAddition(l map (_.replace(y, t))).propagateSign(this).simplified } /** Returns the list of input variables contained in this addition. */ def input_variables: List[InputVar] = { (l flatMap (_.input_variables)).distinct } } /** Class representing an absolute value of an input term. */ case class APAInputAbs(arg: APAInputTerm) extends APAInputTerm { setSign(SignAbstraction.absSign(arg)) /** Returns a clone of this absolute value without the abstraction. */ def normalClone():this.type = APAInputAbs(arg).asInstanceOf[this.type] /** Returns a simplified version of this absolute value. */ def simplified:APAInputTerm = { if(isZero) return APAInputCombination(0) val result = arg.simplified match { case t if t.isPositiveZero => t case APAInputCombination(i, Nil) => APAInputCombination(Math.abs(i), Nil) case t => APAInputAbs(t) } result.propagateSign(this) } /** Returns an expression where all occurences of the variable y have been replaced by t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { val result = APAInputAbs(arg.replace(y, t)).simplified result.propagateSign(this) } /** Returns the list of input variables contained in this absolute value. */ def input_variables: List[InputVar] = { arg.input_variables } } /** Class representing the gcd of a list of input terms. * The list of input terms should be guaranteed not to be all zero at the same time. */ case class APAInputGCD(l: List[APAInputTerm]) extends APAInputTerm { setSign(1) /** Returns a clone of this gcd without the abstraction. */ def normalClone():this.type = APAInputGCD(l).asInstanceOf[this.type] /** Returns a simplified version of this gcd. */ def simplified:APAInputTerm = { if(isZero) return APAInputCombination(0) val (integers, non_integers) = APAInputTerm.partitionInteger(l map (_.simplified)) val result = (Common.gcdlistComplete(integers), non_integers) match { case (Some(1), _) => APAInputCombination(1, Nil) case (None, k::Nil) => APAInputAbs(k).simplified case (None, Nil) => throw new Error("GCD is not defined on an empty set") case (None, l) => APAInputGCD(l) case (Some(n), Nil) => APAInputAbs(APAInputCombination(n, Nil)).simplified case (Some(n), l) => APAInputGCD(APAInputCombination(n, Nil)::l) } result.propagateSign(this) } /** Returns an expression where all occurences of the variable y have been replaced by t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { APAInputGCD(l map (_.replace(y, t))).simplified.propagateSign(this) } /** Returns the list of input variables contained in this gcd. */ def input_variables: List[InputVar] = { (l flatMap (_.input_variables)).distinct } } /** Class representing the lcm of a list of input terms. */ case class APAInputLCM(l: List[APAInputTerm]) extends APAInputTerm { setSign(1) /** Returns a clone of this lcm without the abstraction. */ def normalClone():this.type = APAInputLCM(l).asInstanceOf[this.type] /** Returns a simplified version of this lcm. */ def simplified:APAInputTerm = { if(isZero) return APAInputCombination(0) val (integers, non_integers) = APAInputTerm.partitionInteger(l map (_.simplified)) val result = (Common.lcmlist(integers), non_integers) match { case (1, Nil) => APAInputCombination(1) case (1, k::Nil) => APAInputAbs(k).simplified case (1, k1::k2::l) if k1 == k2 => APAInputLCM(k2::l).simplified case (1, l) => APAInputLCM(l) case (n, Nil) => APAInputAbs(APAInputCombination(n, Nil)).simplified case (n, l) => APAInputLCM(APAInputCombination(n, Nil)::l) } result.propagateSign(this) } /** Returns an expression where all occurences of the variable y have been replaced by t. */ def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { APAInputLCM(l map (_.replace(y, t))).simplified.propagateSign(this) } /** Returns the list of input variables contained in this lcm. */ def input_variables: List[InputVar] = { (l flatMap (_.input_variables)).distinct } } /* case class APAInputMod(operand: APAInputTerm, divisor: APAInputTerm) extends APAInputTerm { setSign(true, true, false) // >= 0 if(divisor.can_be_zero) throw new Exception("Error : "+divisor+" can be zero in expression "+this) def normalClone():this.type = APAInputMod(operand, divisor).asInstanceOf[this.type] def simplified:APAInputTerm = { if(isZero) return APAInputCombination(0) val result = (operand.simplified, divisor.simplified) match { case (APAInputCombination(0, Nil), _) => APAInputCombination(0, Nil) case (_, APAInputCombination(1, Nil)) => APAInputCombination(0, Nil) case (APAInputCombination(i, Nil), APAInputCombination(j, Nil)) if j != 0 => APAInputCombination(Common.smod(i, j), Nil) case (o, d) => APAInputMod(o, d) } result.propagateSign(this) } def replace(y: InputVar, t: APAInputTerm):APAInputTerm = { APAInputMod(operand.replace(y, t), divisor.replace(y, t)).simplified.propagateSign(this) } def input_variables: List[InputVar] = { (operand.input_variables ++ divisor.input_variables).distinct } }*/
epfl-lara/comfusy
src/main/scala/APAInputSyntaxTree.scala
Scala
bsd-2-clause
30,642
/* * Copyright (C) 2009-2013 Typesafe Inc. <http://www.typesafe.com> */ package play.it.http.parsing import play.api.libs.iteratee.Enumerator import play.api.libs.json.{ Json, JsError } import play.api.mvc.Results.BadRequest import play.api.mvc.{ BodyParser, BodyParsers } import play.api.test._ object JsonBodyParserSpec extends PlaySpecification { private case class Foo(a: Int, b: String) private implicit val fooFormat = Json.format[Foo] "The JSON body parser" should { def parse[A](json: String, contentType: Option[String], encoding: String, bodyParser: BodyParser[A] = BodyParsers.parse.tolerantJson) = { await(Enumerator(json.getBytes(encoding)) |>>> bodyParser(FakeRequest().withHeaders(contentType.map(CONTENT_TYPE -> _).toSeq: _*))) } "parse JSON bodies" in new WithApplication() { parse("""{"foo":"bar"}""", Some("application/json"), "utf-8") must beRight.like { case json => (json \ "foo").as[String] must_== "bar" } } "automatically detect the charset" in new WithApplication() { parse("""{"foo":"bär"}""", Some("application/json"), "utf-8") must beRight.like { case json => (json \ "foo").as[String] must_== "bär" } parse("""{"foo":"bär"}""", Some("application/json"), "utf-16") must beRight.like { case json => (json \ "foo").as[String] must_== "bär" } parse("""{"foo":"bär"}""", Some("application/json"), "utf-32") must beRight.like { case json => (json \ "foo").as[String] must_== "bär" } } "ignore the supplied charset" in new WithApplication() { parse("""{"foo":"bär"}""", Some("application/json; charset=iso-8859-1"), "utf-16") must beRight.like { case json => (json \ "foo").as[String] must_== "bär" } } "accept all common json content types" in new WithApplication() { parse("""{"foo":"bar"}""", Some("application/json"), "utf-8", BodyParsers.parse.json) must beRight.like { case json => (json \ "foo").as[String] must_== "bar" } parse("""{"foo":"bar"}""", Some("text/json"), "utf-8", BodyParsers.parse.json) must beRight.like { case json => (json \ "foo").as[String] must_== "bar" } } "reject non json content types" in new WithApplication() { parse("""{"foo":"bar"}""", Some("application/xml"), "utf-8", BodyParsers.parse.json) must beLeft parse("""{"foo":"bar"}""", None, "utf-8", BodyParsers.parse.json) must beLeft } "gracefully handle invalid json" in new WithApplication() { parse("""{"foo:}""", Some("application/json"), "utf-8", BodyParsers.parse.json) must beLeft } "validate json content using .validate" in new WithApplication() { import scala.concurrent.ExecutionContext.Implicits.global val fooParser = BodyParsers.parse.json.validate { _.validate[Foo].asEither.left.map(e => BadRequest(JsError.toFlatJson(e))) } parse("""{"a":1,"b":"bar"}""", Some("application/json"), "utf-8", fooParser) must beRight parse("""{"foo":"bar"}""", Some("application/json"), "utf-8", fooParser) must beLeft parse("""{"a":1}""", Some("application/json"), "utf-8", fooParser) must beLeft } "validate json content using implicit reads" in new WithApplication() { parse("""{"a":1,"b":"bar"}""", Some("application/json"), "utf-8", BodyParsers.parse.json[Foo]) must beRight.like { case foo => foo must_== Foo(1, "bar") } parse("""{"foo":"bar"}""", Some("application/json"), "utf-8", BodyParsers.parse.json[Foo]) must beLeft parse("""{"a":1}""", Some("application/json"), "utf-8", BodyParsers.parse.json[Foo]) must beLeft parse("""{"foo:}""", Some("application/json"), "utf-8", BodyParsers.parse.json[Foo]) must beLeft } } }
jyotikamboj/container
pf-framework/src/play-integration-test/src/test/scala/play/it/http/parsing/JsonBodyParserSpec.scala
Scala
mit
3,796
/* Copyright 2017-19, Emmanouil Antonios Platanios. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package org.platanios.tensorflow.api.ops import org.platanios.tensorflow.api.core.exception.InvalidDataTypeException import org.platanios.tensorflow.api.core.types._ import org.platanios.tensorflow.api.implicits.Implicits._ import org.platanios.tensorflow.api.ops import org.platanios.tensorflow.api.ops.basic.Basic import org.platanios.tensorflow.api.ops.control_flow.{Context, ControlFlow, GradientState} import org.platanios.tensorflow.api.ops.math.Math import org.platanios.tensorflow.api.utilities.DefaultsTo.AnyDefault import org.platanios.tensorflow.jni.{Graph => NativeGraph, Output => NativeOutput} import com.typesafe.scalalogging.Logger import org.slf4j.LoggerFactory import scala.collection.compat._ import scala.collection.mutable /** * @author Emmanouil Antonios Platanios */ object Gradients { val logger = Logger(LoggerFactory.getLogger("Gradients")) private[ops] trait API { val gradients: ops.Gradients.type = ops.Gradients } // TODO: [GRADIENTS] !!! Figure out what the right signature for the gradient functions should be. type GradientFn[I, O, GI >: I, GO >: O] = ( /* Op */ Op[I, O], /* Output Gradients */ GO) => GI type UntypedGradientFn = GradientFn[Seq[OutputLike[Any]], Seq[OutputLike[Any]], Seq[OutputLike[Any]], Seq[OutputLike[Any]]] private[ops] def convertGradientFn[I, O, GI >: I, GO >: O]( gradientFn: Gradients.GradientFn[I, O, GI, GO] )(implicit evGI: Op.OpInput[GI], evGO: Op.OpOutput[GO] ): Gradients.UntypedGradientFn = { def gradient( op: Op[Seq[OutputLike[Any]], Seq[OutputLike[Any]]], outputGradients: Seq[OutputLike[Any]] ): Seq[OutputLike[Any]] = { val oGradients = implicitly[Op.OpOutput[GO]].fromOutputLikes(outputGradients) val iGradient = gradientFn(op.asInstanceOf[Op[I, O]], oGradients) implicitly[Op.OpInput[GI]].toOutputLikes(iGradient) } gradient } def unaryHelper[T: TF, OL[A] <: OutputLike[A], GO[A] >: OL[A]]( output: Output[T], outputGradient: OL[T], opType: String, name: String, gradientFn: Option[GradientFn[(Output[T], OL[T]), Output[T], (Output[T], GO[T]), Output[T]]] = None ): OL[T] = { type GF[O[A]] = Option[GradientFn[(Output[T], O[T]), Output[T], (Output[T], O[T]), Output[T]]] val gradient = outputGradient match { case g: Output[T] => Op.Builder[(Output[T], Output[T]), Output[T]]( opType = opType, name = name, input = (output, g) ).setGradientFnHelper(gradientFn.asInstanceOf[GF[Output]]) .build().output case g: OutputIndexedSlices[T] => val values = Op.Builder[(Output[T], OutputIndexedSlices[T]), Output[T]]( opType = opType, name = name, input = (output, g) ).setGradientFnHelper(gradientFn.asInstanceOf[GF[OutputIndexedSlices]]) .build().output OutputIndexedSlices(indices = g.indices, values = values, denseShape = g.denseShape) case g: SparseOutput[T] => val values = Op.Builder[(Output[T], SparseOutput[T]), Output[T]]( opType = opType, name = name, input = (output, g) ).setGradientFnHelper(gradientFn.asInstanceOf[GF[SparseOutput]]) .build().output SparseOutput(indices = g.indices, values = values, denseShape = g.denseShape) } gradient.asInstanceOf[OL[T]] } // TODO: [DOC] Document the "gradients" function. /** * * Note that ops/graphs created outside TensorFlow Scala are not differentiable. * * @param ys * @param xs * @param dataType * @param dys * @param gateGradients * @param aggregationMethod * @param colocateGradientsWithOps * @param name * @return */ def gradients[T: TF, I: AnyDefault]( ys: Seq[Output[Any]], xs: Seq[Output[I]], dataType: DataType[T], dys: Seq[OutputLike[T]] = null, gateGradients: Boolean = false, aggregationMethod: AggregationMethod = AddAggregationMethod, colocateGradientsWithOps: Boolean = false, name: String = "Gradients" ): Seq[OutputLike[T]] = Op.currentGraph.synchronized { // The `accumulatedGradients` variable collects the gradients received on each output endpoint of the op. The // gradients for each endpoint are initially collected as a sequence. When it is time to call the op's gradient // function, for each endpoint we aggregate the list of received gradients into a "add" operation, if there is more // than one. val accumulatedGradients = mutable.Map.empty[UntypedOp, mutable.Seq[Seq[OutputLike[Any]]]] Op.nameScope(name) { // Get a UID for this call to gradients that can be used to help cluster ops for compilation. val gradientUID = Op.currentGraph.uniqueName("GradientUID") // The approach we take here is as follows: Create a list of all ops in the sub-graph between the ys and xs. Visit // these ops in reverse order of ids to ensure that when we visit an op the gradients with respect to its outputs // have been collected. Then, aggregate these gradients if needed, call the op's gradient function, and add the // generated gradients to the gradients for its input. // Initialize the pending counts for ops in the connected sub-graph between the ys and xs. val sourceOps = xs.map(_.op).toSet val destinationOps = ys.map(_.op).toSet // `pendingCounts(op)` is a count-down counter for the expected gradients to accumulate for `op`. When // `pendingCounts(op)` becomes zero, we have collected all the backpropagation gradients for all outputs of `op`. val (pendingCounts, controlFlowGradientState) = initialPendingCounts( sourceOps, destinationOps, colocateGradientsWithOps) // `readyOps` keeps track of ops that have been completely processed. We initialize it with the destination ops. // We filter the destination ops based on whether one output gradient relies on another output's gradient. val readyOps = mutable.Queue( destinationOps.filter(pendingCounts.getOrElse(_, 0) == 0).toSeq: _*) // Add the initial gradients for the ys. val dyInitial = initialGradients(dataType, ys, dys, colocateGradientsWithOps, gradientUID) for ((y, dy) <- ys.zip(dyInitial)) setGradient(accumulatedGradients, y, dy) controlFlowGradientState.foreach(state => { state.processUnusedLoopExits(pendingCounts, destinationOps) .filter(isTrainable) .foreach(loopExit => { val zeros = state.zerosLikeForExit(loopExit)(TF.fromDataType(loopExit.dataType)) val castedZeros = zeros.castTo[T] setGradient(accumulatedGradients, loopExit, castedZeros) readyOps.enqueue(loopExit.op) }) }) // Stop ops form the frontier of the forward graph before which back-propagation should stop. Ops in this set will // not be differentiated. This set is defined as the subset of `sourceOps` containing ops that have no predecessor // in `sourceOps`. An op has predecessors in `sourceOps` if and only if `pendingCounts(op) > 0`. val stopOps = sourceOps.filter(_.inputsSeq.forall(i => pendingCounts.getOrElse(i.op, 0) <= 0)) while (readyOps.nonEmpty) { val op = readyOps.dequeue() maybeColocateWith(op, colocateGradientsWithOps, gradientUID) { controlFlowGradientState.foreach(_.enterGradientWhileLoopContext(op, before = true)) val opGradients = aggregationMethod.aggregateGradients(accumulatedGradients, op, gradientUID) controlFlowGradientState.foreach(_.exitGradientWhileLoopContext(op, before = true)) val hasOutputGradients = opGradients.nonEmpty val hasGradientFn = hasOutputGradients && !stopOps.contains(op) && op.hasGradient controlFlowGradientState.foreach(_.enterGradientWhileLoopContext(op, before = false)) if (hasOutputGradients && hasGradientFn) { // Note that, the gradient aggregation not computing a value for the i'th output, means that the cost does // not depend on output i and therefore the gradient with respect to that output is 0. for ((gradient, outputIndex) <- opGradients.zipWithIndex) { // Only floating-point outputs get a zero gradient. Gradient functions should ignore the gradient for // other outputs. val output = op.outputsSeq(outputIndex) if (gradient.isEmpty && isTrainable(output)) // TODO: !!! [GRADIENTS] Gradients of resource handles might be an issue here because of the zeros. opGradients(outputIndex) = Seq( controlFlowGradientState .map(_.zerosLike(op, outputIndex)) .getOrElse(Some(Context.zerosLikeOutsideLoop(op, outputIndex))) .orNull) } // Compute the actual op gradients. Op.createWith(nameScope = s"${op.name}Gradient") { // TODO: [CONTEXT] Add support for original op context. val outputGradients = opGradients.map(_.headOption.orNull) var inputGradients = maybeCompile(name, op, () => op.gradientFn.get(op, outputGradients.toSeq)) if (gateGradients && inputGradients.count(_ != null) > 1) { Op.createWith(device = null) { Op.colocateWithForGradient( Set.empty, Some(gradientUID), ignoreExisting = true ) { val dataType = inputGradients.find(_ != null).get.dataType inputGradients = ControlFlow.tuple(inputGradients)(TF.fromDataType(dataType)) } } } val nInp = op.inputsSeq.length val nGrd = inputGradients.length assert(nInp == nGrd, s"Gradients size ($nGrd) for op '$op' does not match inputs size ($nInp).") logGradients(op, outputGradients.toSeq, inputGradients) // TODO: [GRADIENTS] !!! Report somehow the non-differentiable ops in the graph. This is currently hard to debug. op.inputsSeq.zip(inputGradients).filter(_._2 != null).foreach(i => { i._2 match { case gradient: Output[_] if i._1.dataType != RESOURCE => gradient.setShape(i._1.shape) case _ => } setGradient(accumulatedGradients, i._1, i._2) }) } } controlFlowGradientState.foreach(_.exitGradientWhileLoopContext(op, before = false)) } // Update the pending counts for the inputs of `op` and enqueue ready ops. op.inputsSeq.foreach(input => { pendingCounts.update(input.op, pendingCounts.getOrElse(input.op, 0) - 1) var ready = pendingCounts(input.op) == 0 if (!ready) controlFlowGradientState.foreach(_ => { ready = pendingCounts(input.op) > 0 && ControlFlow.isLoopSwitch(input.op) }) if (ready) { if (ControlFlow.isLoopExit(input.op)) { // If `input` is an exit without real gradient, defer processing them. controlFlowGradientState.flatMap(_.getGradientLoopState(input.op, before = false)).foreach(state => { state.deferredExits += input state.pendingExitsCount -= 1 if (state.pendingExitsCount == 0) { // We now have all the exits and so we process them. var hasRealGradient = false state.deferredExits.foreach(exit => { if (accumulatedGradients.get(exit.op).exists(_.exists(_.exists(_ != null)))) { hasRealGradient = true readyOps.enqueue(exit.op) } else { state.unusedExits += exit } }) if (hasRealGradient) { // For an unused exit, if it has floating-point outputs, we back-propagate a zero gradient. // Otherwise, we just ignore it. state.unusedExits.foreach(exit => { if (isTrainable(exit)) { val zeros = controlFlowGradientState.get .zerosLikeForExit(exit)(TF.fromDataType(exit.dataType)) val castedZeros = zeros.castTo[T] setGradient(accumulatedGradients, exit, castedZeros) } readyOps.enqueue(exit.op) }) } else { // All exits are "unused" and so we use `null` as the gradient. state.unusedExits.foreach(exit => readyOps.enqueue(exit.op)) } } }) } else { readyOps.enqueue(input.op) } } }) } controlFlowGradientState.foreach(_.postProcess()) } // Collect the aggregated gradients for the requested tensors and return them. xs.map(x => { val gradients = accumulatedGradients.get(x.op).map(_.apply(x.index)) if (gradients.isDefined && gradients.get.lengthCompare(1) > 0) throw new IllegalArgumentException("The gradients should have been aggregated by now.") gradients.map(_.head.asInstanceOf[OutputLike[T]]).orNull }) } /** If `colocateGradientsWithOps` is `true`, then all ops created within `block` will be colocated with `op`. * * @param op Op to maybe colocate with. * @param colocateGradientsWithOps Boolean value indicating whether to colocate the gradient ops with the original * ops. * @param gradientUID Unique identifier within the graph indicating which invocation of gradients is * being executed. Used to cluster ops for compilation. * @param block Block of code to execute using the specified colocation ops. * @return Return value of `block`. */ private def maybeColocateWith[R]( op: UntypedOp, colocateGradientsWithOps: Boolean, gradientUID: String )(block: => R): R = { if (colocateGradientsWithOps) Op.colocateWithForGradient(Set(op), Some(gradientUID))(block) else block } // TODO: [FUNCTIONAL] Symbolic gradient ('_SymGrad'). /** If the op was marked as compiled, this function compiles the calculation in `gradientFunction` (using XLA) and * returns the result of `gradientFunction`. Otherwise, it simply returns the result of `gradientFunction`. * * @param nameScope Name scope to use for the gradient ops. * @param op Op whose gradients are being computed. * @param gradientFunction Function that computes the gradients for `op`. * @return Created gradients op. */ private def maybeCompile( nameScope: String, op: UntypedOp, gradientFunction: () => Seq[OutputLike[Any]] ): Seq[OutputLike[Any]] = { // TODO: [FUNCTIONAL] Add extra 'func' argument. val cleanNameScope = nameScope.stripSuffix("/").replace('/', '_') try { val xlaCompile = op.booleanAttribute("_XlaCompile") if (!xlaCompile) { gradientFunction() // Exit early } else { val xlaSeparateCompileGradient = op.booleanAttribute("_XlaSeparateCompiledGradients") val xlaScope = op.stringAttribute("_XlaScope") // If the gradients are supposed to be compiled separately, we give them an '_XlaScope' name that is based on // the name_scope of the gradients. Otherwise, they just inherit the existing '_XlaScope' name, which lets them // be merged together with the non-gradient computation. val xlaGradientsScope = if (xlaSeparateCompileGradient) s"${xlaScope}_grad_$cleanNameScope" else xlaScope Op.createWith(attributes = Map( "_XlaCompile" -> xlaCompile, "_XlaScope" -> xlaGradientsScope) ) { gradientFunction() } } } catch { case _: IllegalArgumentException => gradientFunction() // Something went wrong and so we exit } } /** Returns a boolean value indicating whether the data type of `tensor` is trainable. This means whether its * gradients can be computed. */ private def isTrainable(tensor: OutputLike[Any]): Boolean = { Set(FLOAT16, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128).contains(tensor.dataType) } /** Computes initial values for the provided gradients, and checks whether their data types are correct. * * @param dataType Data type of the gradients. * @param ys Sequence containing the variables corresponding to `dys`. * @param dys Sequence containing tensor gradients. * @param colocateGradientsWithOps Boolean value indicating whether to colocate the gradient ops with the original * ops. * @param gradientUID Unique identifier within the graph indicating which invocation of gradients is * being executed. Used to cluster ops for compilation. * @return Sequence containing the default gradient values. * @throws InvalidDataTypeException If the gradient tensor data types are not compatible with the input data types. */ @throws[InvalidDataTypeException] private def initialGradients[T: TF]( dataType: DataType[T], ys: Seq[OutputLike[Any]], dys: Seq[OutputLike[T]], colocateGradientsWithOps: Boolean, gradientUID: String = "__unsupported__" ): Seq[OutputLike[T]] = { ys.zip(if (dys != null) dys else Seq.fill[OutputLike[T]](ys.length)(null)) .zipWithIndex.map { case ((y, dy), index) => if (dy == null) { if (y.dataType.isComplex) { throw InvalidDataTypeException( s"Gradients of complex tensors must " + s"set 'gradients' (variable.dataType = '${y.dataType}').") } maybeColocateWith(y.op, colocateGradientsWithOps, gradientUID) { y match { case o: Output[_] => Op.nameScope(s"Gradients_$index") { if (o.shape.isFullyDefined) { Basic.ones[T](o.shape) } else { Basic.ones[T](Basic.shape(o)(TF.fromDataType(o.dataType))) } } case o: OutputIndexedSlices[_] => if (o.denseShape == null) { throw new IllegalArgumentException( "The dense shape of output indexed slices must " + "be known in order to obtain their gradients.") } Op.nameScope(s"Gradients_$index") { Basic.ones[T](o.denseShape) } case o: SparseOutput[_] => Op.nameScope(s"Gradients_$index") { Basic.ones[T, Long](o.denseShape) } } } } else { if (y.dataType.isFloatingPoint || y.dataType.isInteger) { if (!dy.dataType.isFloatingPoint && !dy.dataType.isInteger) { throw InvalidDataTypeException( s"Gradient data type '${dy.dataType}' generated for " + s"real or integer-valued tensor '$y' with data type " + s"'${y.dataType}' must be real or integer.") } } else if (y.dataType.isComplex) { if (!dy.dataType.isComplex) { throw InvalidDataTypeException( s"Gradient data type '${dy.dataType}' generated for " + s"complex-valued tensor '$y' with data type " + s"'${y.dataType}' must be complex.") } } else { throw InvalidDataTypeException( s"Tensor '$y' with data type '${y.dataType}' must " + s"be numeric in order to obtain a default gradient.") } // Create a gradients tensor in the name scope of the gradients. This is required in order for tensor arrays // to identify which gradient call a gradient value is coming from. dy match { case o: Output[T] => Basic.identity(o, name = s"Gradients_$index") case o: OutputIndexedSlices[T] => OutputIndexedSlices( Basic.identity(o.indices, name = s"Gradients_${index}_Indices"), Basic.identity(o.values, name = s"Gradients_${index}_Values"), if (o.denseShape == null) o.denseShape else Basic.identity(o.denseShape, name = s"Gradients_${index}_DenseShape")) case o: SparseOutput[T] => SparseOutput( Basic.identity(o.indices, name = s"Gradients_${index}_Indices"), Basic.identity(o.values, name = s"Gradients_${index}_Values"), if (o.denseShape == null) o.denseShape else Basic.identity(o.denseShape, name = s"Gradients_${index}_DenseShape")) } } } } /** Initializes the back-propagation input counts for ops between two sets of ops. * * 'outputMap(op)' indicates the number of back-propagation inputs to this op. * * @param sourceOps Set of source ops. * @param destinationOps Set of destination ops. * @param colocateGradientsWithOps Boolean value indicating whether to colocate the gradient ops with the original * ops. * @return Tuple containing: (1) Map from op to the number of back-propagation inputs to this op, and (2) a control * flow gradient state object which is not `None` if the ops between `sources` and `destinations` contain * control flow loops. */ private def initialPendingCounts( sourceOps: Set[UntypedOp], destinationOps: Set[UntypedOp], colocateGradientsWithOps: Boolean ): (mutable.Map[UntypedOp, Int], Option[GradientState]) = { // Mark ops reached when going from 'sources' to 'destinations' val reached = mutable.Set(destinationOps.toSeq: _*) val reachedQueue = mutable.Queue(sourceOps.toSeq: _*) while (reachedQueue.nonEmpty) { val op = reachedQueue.dequeue() if (!reached.contains(op)) { reached += op op.outputsSeq.foreach(_.consumers.foreach(c => reachedQueue.enqueue(c.op))) } } // Mark ops between 'sources' and 'destinations' val between = mutable.Set.empty[UntypedOp] // TODO: [CONTROL_FLOW] Do we need the list aside from the set? val betweenList = mutable.ListBuffer.empty[UntypedOp] val betweenQueue = mutable.Queue(destinationOps.toSeq: _*) while (betweenQueue.nonEmpty) { val op = betweenQueue.dequeue() if (reached.contains(op)) { between += op betweenList += op reached -= op // Done so we don't go through the same ops twice op.inputsSeq.foreach(i => betweenQueue.enqueue(i.op)) } } // `controlFlowGradientState` is `None` if there are no while loops. val controlFlowGradientState = GradientState.maybeCreate( between, betweenList, colocateGradientsWithOps) // Initialize the pending counts for the between ops val pendingCounts = mutable.Map.empty[UntypedOp, Int] betweenList .flatMap(_.inputsSeq) .map(_.op) .filter(between.contains) .foreach(input => { pendingCounts.update(input, pendingCounts.getOrElse(input, 0) + 1) }) (pendingCounts, controlFlowGradientState) } /** Adds the provided `gradient` to the sequence of `output`'s gradients that have been collected so far. * * @param gradients Map where the collected gradients are stored. * @param output Op output whose gradient is provided. * @param gradient Gradient of `output` to add to the collected gradients. */ private def setGradient( gradients: mutable.Map[UntypedOp, mutable.Seq[Seq[OutputLike[Any]]]], output: Output[Any], gradient: OutputLike[Any] ): Unit = { val opGradients = gradients.getOrElseUpdate( output.op, mutable.Seq(output.op.outputsSeq.map(_ => Seq.empty): _*)) if (ControlFlow.isLoopSwitch(output.op)) opGradients(output.index) = Seq(gradient) else opGradients(output.index) :+= gradient } /** Logs the input and output gradients of the provided op. * * @param op Op. * @param outputGradients Output gradients of op. * @param inputGradients Input gradients of op. */ private def logGradients( op: UntypedOp, outputGradients: Seq[OutputLike[Any]], inputGradients: Seq[OutputLike[Any]] ): Unit = { logger.debug(s"Gradients for op '${op.name}':") logger.debug(s" in --> ${outputGradients.filter(_ != null).map(_.name).mkString(", ")}") logger.debug(s" out --> ${inputGradients.filter(_ != null).map(_.name).mkString(", ")}") } sealed trait GatingMethod object NoGating extends GatingMethod object OpGating extends GatingMethod object GraphGating extends GatingMethod /** Aggregation method used to combine gradients. * * Computing partial derivatives can require aggregating gradient contributions. All such aggregation methods are * represented as objects extending this trait. */ sealed trait AggregationMethod { /** Aggregate the gradients for op `op`. * * @param gradients Map where the collected gradients are stored. The gradient sequences corresponding to `op` * will be replaced with sequences containing a single element corresponding to the aggregated * gradient. * @param op Op whose gradients to aggregate. * @param gradientUID Unique identifier within the graph indicating which invocation of gradients is being * executed. Used to cluster ops for compilation. */ private[Gradients] def aggregateGradients( gradients: mutable.Map[UntypedOp, mutable.Seq[Seq[OutputLike[Any]]]], op: UntypedOp, gradientUID: String ): mutable.Seq[Seq[OutputLike[Any]]] = { val opGradients = gradients.getOrElse(op, mutable.Seq.empty[Seq[OutputLike[Any]]]) if (ControlFlow.isLoopSwitch(op)) { opGradients } else { opGradients.zipWithIndex.foreach { case (grads, index) => if (grads.length < 2) { grads } else { val gs = grads.filter(_ != null) opGradients(index) = Seq( aggregate(gs, Some(gradientUID))(TF.fromDataType(gs.head.dataType))) } } opGradients } } /** Aggregates `values` into a single tensor. * * @param values Sequence of values to aggregate. * @param gradientUID Unique identifier within the graph indicating which invocation of gradients is being * executed (if any). Used to cluster ops for compilation. * @return Aggregated tensor. */ private[ops] def aggregate[T: TF]( values: Seq[OutputLike[T]], gradientUID: Option[String] = None ): OutputLike[T] } /** Gradient aggregation method that simply adds up the collected gradients. */ object AddAggregationMethod extends AggregationMethod { override private[ops] def aggregate[T: TF]( gradients: Seq[OutputLike[T]], gradientUID: Option[String] = None ): OutputLike[T] = { // TODO: [TYPES] !!! Super hacky. Remove in the future. implicit val ev: IsNumeric[T] = null if (gradients.forall(_.isInstanceOf[OutputIndexedSlices[T]])) { def addNOutputIndexedSlices( gradients: Seq[OutputIndexedSlices[T]] ): OutputIndexedSlices[T] = { if (gradients.isEmpty) { throw new IllegalArgumentException( "Can not aggregate empty gradients list.") } else if (gradients.length == 1) { gradients.head } else { OutputIndexedSlices( Basic.concatenate(gradients.map(_.indices)), Basic.concatenate(gradients.map(_.values)), gradients.head.denseShape) } } val deviceContributions = gradients.groupBy(_.device).toSeq.sortBy(_._1).map { case (_, outputs) => addNOutputIndexedSlices( outputs.map(_.asInstanceOf[OutputIndexedSlices[T]])) } addNOutputIndexedSlices(deviceContributions) } else { // This function adds op outputs from potentially different devices. // We add the tensors of each device separately first, and we then add up the partial results. val deviceContributions = gradients.groupBy(_.device).toSeq.sortBy(_._1).map { case (_, outputs) => Op.colocateWithForGradient( Set(gradients.head.op), gradientUID, ignoreExisting = true ) { Math.addN(outputs.map(_.toOutput)) } } Math.addN(deviceContributions) } } } /** Gradient aggregation method that simply adds up the collected gradients, without first waiting for all of them to * become available at once. * * The benefit of using this method is that its inputs can be combined in any order and this can allow the expression * to be evaluated with a smaller memory footprint. With this method, it is possible to compute a sum of terms which * are much larger than total GPU memory. */ object AccumulateAggregationMethod extends AggregationMethod { override private[ops] def aggregate[T: TF]( gradients: Seq[OutputLike[T]], gradientUID: Option[String] = None ): OutputLike[T] = { // TODO: [TYPES] !!! Super hacky. Remove in the future. implicit val ev: IsNumeric[T] = null if (gradients.forall(_.isInstanceOf[Output[T]])) { Math.accumulateN(gradients.map(_.asInstanceOf[Output[T]])) } else if (gradients.forall(_.isInstanceOf[OutputIndexedSlices[T]])) { def addNOutputIndexedSlices( gradients: Seq[OutputIndexedSlices[T]] ): OutputIndexedSlices[T] = { if (gradients.isEmpty) { throw new IllegalArgumentException( "Can not aggregate empty gradients list.") } else if (gradients.length == 1) { gradients.head } else { OutputIndexedSlices( Basic.concatenate(gradients.map(_.indices)), Basic.concatenate(gradients.map(_.values)), gradients.head.denseShape) } } val deviceContributions = gradients.groupBy(_.device).toSeq.sortBy(_._1).map { case (_, outputs) => addNOutputIndexedSlices( outputs.map(_.asInstanceOf[OutputIndexedSlices[T]])) } addNOutputIndexedSlices(deviceContributions) } else { throw new IllegalArgumentException( "The gradients being aggregated need to be all " + "of type 'Output' or 'OutputIndexedSlices'.") } } } /** Adds ops to the graph to compute the partial derivatives of the sum of `y`s with respect to the `x`s, using the * C++ gradients support of the TensorFlow native library. * * Note that the C++ gradients support of the TensorFlow native library is incomplete and will not be sufficient for * many use cases. It is mainly exposed as means of comparison to the Scala API functionality. * * The result of this function is an array containing: `d(y_1 + y_2 + ...)/dx_1`, `d(y_1 + y_2 + ...)/dx_2`, `...`. * * @param y Tensors whose partial derivatives are computed. * @param x Tensors with respect to which the gradients are computed. * @param dy Tensors to use as the initial gradients. They represent the symbolic partial derivatives of some loss * function `L` with respect to `y`. If `null`, then ones are used. The number of tensors in `dx` must * match the number of tensors in `y`. * @return Partial derivatives of the `y`s given each one of the `x`s. * @throws IllegalArgumentException If the length of `y` does not match the length of `dx`. */ @throws[IllegalArgumentException] def ccGradients[T: TF, O]( y: Array[Output[O]], x: Array[Output[T]], dy: Array[Output[T]] = null ): Array[Output[T]] = { // TODO: Overload this method with all possible uses for it. if (dy != null && dy.length != y.length) { throw new IllegalArgumentException( s"The number of ys (${y.length}) must match the number of dxs (${dy.length}).") } // Obtain the graph and verify that all provided op outputs are defined over the same graph val graph = y.head.graph y.foreach(o => Op.assertSameGraph(o.op, y.head.op)) x.foreach(o => Op.assertSameGraph(o.op, y.head.op)) if (dy != null) dy.foreach(o => Op.assertSameGraph(o.op, y.head.op)) // Map all arrays to the corresponding data structures used by the JNI layer val yJNI = y.map(o => NativeOutput(o.op.nativeHandle, o.index)) val xJNI = x.map(o => NativeOutput(o.op.nativeHandle, o.index)) val dxJNI = if (dy == null) null else dy.map(o => NativeOutput(o.op.nativeHandle, o.index)) // Add the gradients to the graph and collect them to the array that is returned val jniGradients = NativeGraph.addGradients(graph.nativeHandle, yJNI, xJNI, dxJNI) jniGradients.map(o => { val op = graph.opsCache.getOrElseUpdate(o.opHandle, { new Op[Seq[Output[Any]], Seq[Output[Any]]](graph, None, o.opHandle) }) Output[T](op, o.outputIndex) }) } }
eaplatanios/tensorflow_scala
modules/api/src/main/scala/org/platanios/tensorflow/api/ops/Gradients.scala
Scala
apache-2.0
34,913
package drt.shared.dates import upickle.default.{ReadWriter, macroRW} case class LocalDate(year: Int, month: Int, day: Int) extends DateLike { override val timeZone: String = "Europe/London" } case object LocalDate { implicit val rw: ReadWriter[LocalDate] = macroRW def parse: String => Option[LocalDate] = DateLike.parse((y: Int, m: Int, d: Int) => LocalDate(y, m, d)) }
UKHomeOffice/drt-scalajs-spa-exploration
shared/src/main/scala/drt/shared/dates/LocalDate.scala
Scala
apache-2.0
383
class Test { def test(b: Base): Unit = b match { case Base_1(Some(_)) => case Base_2(Nested_1(_)) => case Base_2(Nested_2(_)) => } }
loskutov/intellij-scala
testdata/scalacTests/pos/t9630/t9630b.scala
Scala
apache-2.0
150
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.flink.table.calcite import org.apache.flink.sql.parser.SqlProperty import org.apache.flink.sql.parser.dml.RichSqlInsert import org.apache.flink.table.calcite.PreValidateReWriter.appendPartitionProjects import org.apache.flink.table.catalog.CatalogReader import org.apache.calcite.plan.RelOptTable import org.apache.calcite.prepare.CalciteCatalogReader import org.apache.calcite.rel.`type`.{RelDataType, RelDataTypeFactory, RelDataTypeField} import org.apache.calcite.runtime.{CalciteContextException, Resources} import org.apache.calcite.sql.`type`.SqlTypeUtil import org.apache.calcite.sql.fun.SqlStdOperatorTable import org.apache.calcite.sql.parser.SqlParserPos import org.apache.calcite.sql.util.SqlBasicVisitor import org.apache.calcite.sql.validate.{SqlValidatorException, SqlValidatorTable, SqlValidatorUtil} import org.apache.calcite.sql.{SqlCall, SqlIdentifier, SqlLiteral, SqlNode, SqlNodeList, SqlSelect, SqlUtil} import org.apache.calcite.util.Static.RESOURCE import java.util import scala.collection.JavaConversions._ /** Implements [[org.apache.calcite.sql.util.SqlVisitor]] * interface to do some rewrite work before sql node validation. */ class PreValidateReWriter( val catalogReader: CatalogReader, val typeFactory: RelDataTypeFactory) extends SqlBasicVisitor[Unit] { override def visit(call: SqlCall): Unit = { call match { case r: RichSqlInsert if r.getStaticPartitions.nonEmpty && r.getSource.isInstanceOf[SqlSelect] => appendPartitionProjects(r, catalogReader, typeFactory, r.getSource.asInstanceOf[SqlSelect], r.getStaticPartitions) case _ => } } } object PreValidateReWriter { //~ Tools ------------------------------------------------------------------ /** * Append the static partitions to the data source projection list. The columns are appended to * the corresponding positions. * * <p>If we have a table A with schema (&lt;a&gt;, &lt;b&gt;, &lt;c&gt) whose * partition columns are (&lt;a&gt;, &lt;c&gt;), and got a query * <blockquote><pre> * insert into A partition(a='11', c='22') * select b from B * </pre></blockquote> * The query would be rewritten to: * <blockquote><pre> * insert into A partition(a='11', c='22') * select cast('11' as tpe1), b, cast('22' as tpe2) from B * </pre></blockquote> * Where the "tpe1" and "tpe2" are data types of column a and c of target table A. * * @param sqlInsert RichSqlInsert instance * @param calciteCatalogReader catalog reader * @param typeFactory type factory * @param select Source sql select * @param partitions Static partition statements */ def appendPartitionProjects(sqlInsert: RichSqlInsert, calciteCatalogReader: CalciteCatalogReader, typeFactory: RelDataTypeFactory, select: SqlSelect, partitions: SqlNodeList): Unit = { val names = sqlInsert.getTargetTable.asInstanceOf[SqlIdentifier].names val table = calciteCatalogReader.getTable(names) if (table == null) { // There is no table exists in current catalog, // just skip to let other validation error throw. return } val targetRowType = createTargetRowType(typeFactory, calciteCatalogReader, table, sqlInsert.getTargetColumnList) // validate partition fields first. val assignedFields = new util.LinkedHashMap[Integer, SqlNode] val relOptTable = table match { case t: RelOptTable => t case _ => null } for (node <- partitions.getList) { val sqlProperty = node.asInstanceOf[SqlProperty] val id = sqlProperty.getKey val targetField = SqlValidatorUtil.getTargetField(targetRowType, typeFactory, id, calciteCatalogReader, relOptTable) validateField(idx => !assignedFields.contains(idx), id, targetField) val value = sqlProperty.getValue.asInstanceOf[SqlLiteral] assignedFields.put(targetField.getIndex, maybeCast(value, value.createSqlType(typeFactory), targetField.getType, typeFactory)) } val currentNodes = new util.ArrayList[SqlNode](select.getSelectList.getList) val fixedNodes = new util.ArrayList[SqlNode] 0 until targetRowType.getFieldList.length foreach { idx => if (assignedFields.containsKey(idx)) { fixedNodes.add(assignedFields.get(idx)) } else if (currentNodes.size() > 0) { fixedNodes.add(currentNodes.remove(0)) } } // Although it is error case, we still append the old remaining // projection nodes to new projection. if (currentNodes.size > 0) { fixedNodes.addAll(currentNodes) } select.setSelectList(new SqlNodeList(fixedNodes, select.getSelectList.getParserPosition)) } /** * Derives a row-type for INSERT and UPDATE operations. * * <p>This code snippet is almost inspired by * [[org.apache.calcite.sql.validate.SqlValidatorImpl#createTargetRowType]]. * It is the best that the logic can be merged into Apache Calcite, * but this needs time. * * @param typeFactory TypeFactory * @param catalogReader CalciteCatalogReader * @param table Target table for INSERT/UPDATE * @param targetColumnList List of target columns, or null if not specified * @return Rowtype */ private def createTargetRowType( typeFactory: RelDataTypeFactory, catalogReader: CalciteCatalogReader, table: SqlValidatorTable, targetColumnList: SqlNodeList): RelDataType = { val baseRowType = table.getRowType if (targetColumnList == null) return baseRowType val fields = new util.ArrayList[util.Map.Entry[String, RelDataType]] val assignedFields = new util.HashSet[Integer] val relOptTable = table match { case t: RelOptTable => t case _ => null } for (node <- targetColumnList) { val id = node.asInstanceOf[SqlIdentifier] val targetField = SqlValidatorUtil.getTargetField(baseRowType, typeFactory, id, catalogReader, relOptTable) validateField(assignedFields.add, id, targetField) fields.add(targetField) } typeFactory.createStructType(fields) } /** Check whether the field is valid. **/ private def validateField(tester: Function[Integer, Boolean], id: SqlIdentifier, targetField: RelDataTypeField): Unit = { if (targetField == null) { throw newValidationError(id, RESOURCE.unknownTargetColumn(id.toString)) } if (!tester.apply(targetField.getIndex)) { throw newValidationError(id, RESOURCE.duplicateTargetColumn(targetField.getName)) } } private def newValidationError(node: SqlNode, e: Resources.ExInst[SqlValidatorException]): CalciteContextException = { assert(node != null) val pos = node.getParserPosition SqlUtil.newContextException(pos, e) } // This code snippet is copied from the SqlValidatorImpl. private def maybeCast(node: SqlNode, currentType: RelDataType, desiredType: RelDataType, typeFactory: RelDataTypeFactory): SqlNode = { if (currentType == desiredType || (currentType.isNullable != desiredType.isNullable && typeFactory.createTypeWithNullability(currentType, desiredType.isNullable) == desiredType)) { node } else { SqlStdOperatorTable.CAST.createCall(SqlParserPos.ZERO, node, SqlTypeUtil.convertTypeToSpec(desiredType)) } } }
bowenli86/flink
flink-table/flink-table-planner/src/main/scala/org/apache/flink/table/calcite/PreValidateReWriter.scala
Scala
apache-2.0
8,294
/* * Copyright 2018 Vladimir Konstantinov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.github.illfaku.korro.dto.ws import akka.actor.ActorRef /** * Response for WebSocket handshake request. * * @param actor Actor that will process WebSocket frames. */ case class WsHandshakeResponse(actor: ActorRef)
oxy-development/korro
src/main/scala/com/github/illfaku/korro/dto/ws/WsHandshakeResponse.scala
Scala
apache-2.0
836
package scala package reflect package internal package tpe import scala.collection.{ mutable } import util.{ Statistics, TriState } import scala.annotation.tailrec trait TypeComparers { self: SymbolTable => import definitions._ import TypesStats._ private final val LogPendingSubTypesThreshold = TypeConstants.DefaultLogThreshhold private val _pendingSubTypes = new mutable.HashSet[SubTypePair] def pendingSubTypes = _pendingSubTypes final case class SubTypePair(tp1: Type, tp2: Type) { // SI-8146 we used to implement equality here in terms of pairwise =:=. // But, this was inconsistent with hashCode, which was based on the // Type#hashCode, based on the structure of types, not the meaning. // Now, we use `Type#{equals,hashCode}` as the (consistent) basis for // detecting cycles (aka keeping subtyping decidable.) // // I added a tests to show that we detect the cycle: neg/t8146-no-finitary* override def toString = tp1+" <:<? "+tp2 } private var _subsametypeRecursions: Int = 0 def subsametypeRecursions = _subsametypeRecursions def subsametypeRecursions_=(value: Int) = _subsametypeRecursions = value private def isUnifiable(pre1: Type, pre2: Type) = ( (isEligibleForPrefixUnification(pre1) || isEligibleForPrefixUnification(pre2)) && (pre1 =:= pre2) ) /** Returns true iff we are past phase specialize, * sym1 and sym2 are two existential skolems with equal names and bounds, * and pre1 and pre2 are equal prefixes */ private def isSameSpecializedSkolem(sym1: Symbol, sym2: Symbol, pre1: Type, pre2: Type) = { sym1.isExistentialSkolem && sym2.isExistentialSkolem && sym1.name == sym2.name && phase.specialized && sym1.info =:= sym2.info && pre1 =:= pre2 } private def isSubPre(pre1: Type, pre2: Type, sym: Symbol) = if ((pre1 ne pre2) && (pre1 ne NoPrefix) && (pre2 ne NoPrefix) && pre1 <:< pre2) { if (settings.debug) println(s"new isSubPre $sym: $pre1 <:< $pre2") true } else false private def equalSymsAndPrefixes(sym1: Symbol, pre1: Type, sym2: Symbol, pre2: Type): Boolean = ( if (sym1 eq sym2) sym1.hasPackageFlag || sym1.owner.hasPackageFlag || phase.erasedTypes || pre1 =:= pre2 else (sym1.name == sym2.name) && isUnifiable(pre1, pre2) ) def isDifferentType(tp1: Type, tp2: Type): Boolean = try { subsametypeRecursions += 1 undoLog undo { // undo type constraints that arise from operations in this block !isSameType1(tp1, tp2) } } finally { subsametypeRecursions -= 1 // XXX AM TODO: figure out when it is safe and needed to clear the log -- the commented approach below is too eager (it breaks #3281, #3866) // it doesn't help to keep separate recursion counts for the three methods that now share it // if (subsametypeRecursions == 0) undoLog.clear() } def isDifferentTypeConstructor(tp1: Type, tp2: Type) = !isSameTypeConstructor(tp1, tp2) private def isSameTypeConstructor(tr1: TypeRef, tr2: TypeRef): Boolean = ( (tr1.sym eq tr2.sym) && !isDifferentType(tr1.pre, tr2.pre) ) private def isSameTypeConstructor(tp1: Type, tp2: Type): Boolean = ( tp1.isInstanceOf[TypeRef] && tp2.isInstanceOf[TypeRef] && isSameTypeConstructor(tp1.asInstanceOf[TypeRef], tp2.asInstanceOf[TypeRef]) ) /** Do `tp1` and `tp2` denote equivalent types? */ def isSameType(tp1: Type, tp2: Type): Boolean = try { if (Statistics.canEnable) Statistics.incCounter(sametypeCount) subsametypeRecursions += 1 //OPT cutdown on Function0 allocation //was: // undoLog undoUnless { // isSameType1(tp1, tp2) // } val before = undoLog.log var result = false try { result = isSameType1(tp1, tp2) } finally if (!result) undoLog.undoTo(before) result } finally { subsametypeRecursions -= 1 // XXX AM TODO: figure out when it is safe and needed to clear the log -- the commented approach below is too eager (it breaks #3281, #3866) // it doesn't help to keep separate recursion counts for the three methods that now share it // if (subsametypeRecursions == 0) undoLog.clear() } // @pre: at least one argument has annotations private def sameAnnotatedTypes(tp1: Type, tp2: Type) = ( annotationsConform(tp1, tp2) && annotationsConform(tp2, tp1) && (tp1.withoutAnnotations =:= tp2.withoutAnnotations) ) // We flush out any AnnotatedTypes before calling isSameType2 because // unlike most other subclasses of Type, we have to allow for equivalence of any // combination of { tp1, tp2 } { is, is not } an AnnotatedType - this because the // logic of "annotationsConform" is arbitrary and unknown. private def isSameType1(tp1: Type, tp2: Type): Boolean = typeRelationPreCheck(tp1, tp2) match { case state if state.isKnown => state.booleanValue case _ if typeHasAnnotations(tp1) || typeHasAnnotations(tp2) => sameAnnotatedTypes(tp1, tp2) case _ => isSameType2(tp1, tp2) } private def isSameHKTypes(tp1: Type, tp2: Type) = ( tp1.isHigherKinded && tp2.isHigherKinded && (tp1.normalize =:= tp2.normalize) ) private def isSameTypeRef(tr1: TypeRef, tr2: TypeRef) = ( equalSymsAndPrefixes(tr1.sym, tr1.pre, tr2.sym, tr2.pre) && (isSameHKTypes(tr1, tr2) || isSameTypes(tr1.args, tr2.args)) ) private def isSameSingletonType(tp1: SingletonType, tp2: SingletonType): Boolean = { // We don't use dealiasWiden here because we are looking for the SAME type, // and widening leads to a less specific type. The logic is along the lines of // dealiasAndFollowUnderlyingAsLongAsTheTypeIsEquivalent. This method is only // called after a surface comparison has failed, so if chaseDealiasedUnderlying // does not produce a type other than tp1 and tp2, return false. @tailrec def chaseDealiasedUnderlying(tp: Type): Type = tp.underlying.dealias match { case next: SingletonType if tp ne next => chaseDealiasedUnderlying(next) case _ => tp } val origin1 = chaseDealiasedUnderlying(tp1) val origin2 = chaseDealiasedUnderlying(tp2) ((origin1 ne tp1) || (origin2 ne tp2)) && (origin1 =:= origin2) } private def isSameMethodType(mt1: MethodType, mt2: MethodType) = ( isSameTypes(mt1.paramTypes, mt2.paramTypes) && (mt1.resultType =:= mt2.resultType.substSym(mt2.params, mt1.params)) && (mt1.isImplicit == mt2.isImplicit) ) private def equalTypeParamsAndResult(tparams1: List[Symbol], res1: Type, tparams2: List[Symbol], res2: Type) = { def subst(info: Type) = info.substSym(tparams2, tparams1) // corresponds does not check length of two sequences before checking the predicate, // but SubstMap assumes it has been checked (SI-2956) ( sameLength(tparams1, tparams2) && (tparams1 corresponds tparams2)((p1, p2) => methodHigherOrderTypeParamsSameVariance(p1, p2) && p1.info =:= subst(p2.info)) && (res1 =:= subst(res2)) ) } // SI-2066 This prevents overrides with incompatible variance in higher order type parameters. private def methodHigherOrderTypeParamsSameVariance(sym1: Symbol, sym2: Symbol) = { def ignoreVariance(sym: Symbol) = !(sym.isHigherOrderTypeParameter && sym.logicallyEnclosingMember.isMethod) !settings.isScala211 || ignoreVariance(sym1) || ignoreVariance(sym2) || sym1.variance == sym2.variance } private def methodHigherOrderTypeParamsSubVariance(low: Symbol, high: Symbol) = !settings.isScala211 || methodHigherOrderTypeParamsSameVariance(low, high) || low.variance.isInvariant def isSameType2(tp1: Type, tp2: Type): Boolean = { def retry(lhs: Type, rhs: Type) = ((lhs ne tp1) || (rhs ne tp2)) && isSameType(lhs, rhs) /* Here we highlight those unfortunate type-like constructs which * are hidden bundles of mutable state, cruising the type system picking * up any type constraints naive enough to get into their hot rods. */ def mutateNonTypeConstructs(lhs: Type, rhs: Type) = lhs match { case BoundedWildcardType(bounds) => bounds containsType rhs case tv @ TypeVar(_, _) => tv.registerTypeEquality(rhs, typeVarLHS = lhs eq tp1) case TypeRef(tv @ TypeVar(_, _), sym, _) => tv.registerTypeSelection(sym, rhs) case _ => false } /* SingletonType receives this additional scrutiny because there are * a variety of Types which must be treated as equivalent even if they * arrive in different guises. For instance, object Foo in the following * might appear in (at least) the four given below. * * package pkg { object Foo ; type Bar = Foo.type } * * ModuleClassTypeRef(pkg.type, Foo: ModuleClassSymbol, Nil) * ThisType(Foo: ModuleClassSymbol) * SingleType(pkg.type, Foo: ModuleSymbol) * AliasTypeRef(NoPrefix, sym: AliasSymbol, Nil) where sym.info is one of the above */ def sameSingletonType = tp1 match { case tp1: SingletonType => tp2 match { case tp2: SingletonType => isSameSingletonType(tp1, tp2) case _ => false } case _ => false } /* Those false cases certainly are ugly. There's a proposed SIP to deuglify it. * https://docs.google.com/a/improving.org/document/d/1onPrzSqyDpHScc9PS_hpxJwa3FlPtthxw-bAuuEe8uA */ def sameTypeAndSameCaseClass = tp1 match { case tp1: TypeRef => tp2 match { case tp2: TypeRef => isSameTypeRef(tp1, tp2) ; case _ => false } case tp1: MethodType => tp2 match { case tp2: MethodType => isSameMethodType(tp1, tp2) ; case _ => false } case RefinedType(ps1, decls1) => tp2 match { case RefinedType(ps2, decls2) => isSameTypes(ps1, ps2) && (decls1 isSameScope decls2) ; case _ => false } case SingleType(pre1, sym1) => tp2 match { case SingleType(pre2, sym2) => equalSymsAndPrefixes(sym1, pre1, sym2, pre2) ; case _ => false } case PolyType(ps1, res1) => tp2 match { case PolyType(ps2, res2) => equalTypeParamsAndResult(ps1, res1, ps2, res2) ; case _ => false } case ExistentialType(qs1, res1) => tp2 match { case ExistentialType(qs2, res2) => equalTypeParamsAndResult(qs1, res1, qs2, res2) ; case _ => false } case ThisType(sym1) => tp2 match { case ThisType(sym2) => sym1 eq sym2 ; case _ => false } case ConstantType(c1) => tp2 match { case ConstantType(c2) => c1 == c2 ; case _ => false } case NullaryMethodType(res1) => tp2 match { case NullaryMethodType(res2) => res1 =:= res2 ; case _ => false } case TypeBounds(lo1, hi1) => tp2 match { case TypeBounds(lo2, hi2) => lo1 =:= lo2 && hi1 =:= hi2 ; case _ => false } case _ => false } ( sameTypeAndSameCaseClass || sameSingletonType || mutateNonTypeConstructs(tp1, tp2) || mutateNonTypeConstructs(tp2, tp1) || retry(normalizePlus(tp1), normalizePlus(tp2)) ) } def isSubType(tp1: Type, tp2: Type, depth: Depth = Depth.AnyDepth): Boolean = try { subsametypeRecursions += 1 //OPT cutdown on Function0 allocation //was: // undoLog undoUnless { // if subtype test fails, it should not affect constraints on typevars // if (subsametypeRecursions >= LogPendingSubTypesThreshold) { // val p = new SubTypePair(tp1, tp2) // if (pendingSubTypes(p)) // false // else // try { // pendingSubTypes += p // isSubType2(tp1, tp2, depth) // } finally { // pendingSubTypes -= p // } // } else { // isSubType2(tp1, tp2, depth) // } // } val before = undoLog.log var result = false try result = { // if subtype test fails, it should not affect constraints on typevars if (subsametypeRecursions >= LogPendingSubTypesThreshold) { val p = new SubTypePair(tp1, tp2) if (pendingSubTypes(p)) false // see neg/t8146-no-finitary* else try { pendingSubTypes += p isSubType1(tp1, tp2, depth) } finally { pendingSubTypes -= p } } else { isSubType1(tp1, tp2, depth) } } finally if (!result) undoLog.undoTo(before) result } finally { subsametypeRecursions -= 1 // XXX AM TODO: figure out when it is safe and needed to clear the log -- the commented approach below is too eager (it breaks #3281, #3866) // it doesn't help to keep separate recursion counts for the three methods that now share it // if (subsametypeRecursions == 0) undoLog.clear() } /** Check whether the subtype or type equivalence relationship * between the argument is predetermined. Returns a tri-state * value: True means the arguments are always sub/same types, * False means they never are, and Unknown means the caller * will have to figure things out. */ private def typeRelationPreCheck(tp1: Type, tp2: Type): TriState = { def isTrue = ( (tp1 eq tp2) || isErrorOrWildcard(tp1) || isErrorOrWildcard(tp2) || (tp1 eq NoPrefix) && tp2.typeSymbol.isPackageClass // !! I do not see how this would be warranted by the spec || (tp2 eq NoPrefix) && tp1.typeSymbol.isPackageClass // !! I do not see how this would be warranted by the spec ) // isFalse, assuming !isTrue def isFalse = ( (tp1 eq NoType) || (tp2 eq NoType) || (tp1 eq NoPrefix) || (tp2 eq NoPrefix) ) if (isTrue) TriState.True else if (isFalse) TriState.False else TriState.Unknown } private def isSubType1(tp1: Type, tp2: Type, depth: Depth): Boolean = typeRelationPreCheck(tp1, tp2) match { case state if state.isKnown => state.booleanValue case _ if typeHasAnnotations(tp1) || typeHasAnnotations(tp2) => annotationsConform(tp1, tp2) && (tp1.withoutAnnotations <:< tp2.withoutAnnotations) case _ => isSubType2(tp1, tp2, depth) } private def isPolySubType(tp1: PolyType, tp2: PolyType): Boolean = { val PolyType(tparams1, res1) = tp1 val PolyType(tparams2, res2) = tp2 sameLength(tparams1, tparams2) && { // fast-path: polymorphic method type -- type params cannot be captured val isMethod = tparams1.head.owner.isMethod //@M for an example of why we need to generate fresh symbols otherwise, see neg/tcpoly_ticket2101.scala val substitutes = if (isMethod) tparams1 else cloneSymbols(tparams1) def sub1(tp: Type) = if (isMethod) tp else tp.substSym(tparams1, substitutes) def sub2(tp: Type) = tp.substSym(tparams2, substitutes) def cmp(p1: Symbol, p2: Symbol) = ( methodHigherOrderTypeParamsSubVariance(p2, p1) && sub2(p2.info) <:< sub1(p1.info) ) (tparams1 corresponds tparams2)(cmp) && (sub1(res1) <:< sub2(res2)) } } // This is looking for situations such as B.this.x.type <:< B.super.x.type. // If it's a ThisType on the lhs and a SuperType on the right, and they originate // in the same class, and the 'x' in the ThisType has in its override chain // the 'x' in the SuperType, then the types conform. private def isThisAndSuperSubtype(tp1: Type, tp2: Type): Boolean = (tp1, tp2) match { case (SingleType(ThisType(lpre), v1), SingleType(SuperType(ThisType(rpre), _), v2)) => (lpre eq rpre) && (v1.overrideChain contains v2) case _ => false } // @assume tp1.isHigherKinded || tp2.isHigherKinded def isHKSubType(tp1: Type, tp2: Type, depth: Depth): Boolean = { def isSub(ntp1: Type, ntp2: Type) = (ntp1.withoutAnnotations, ntp2.withoutAnnotations) match { case (TypeRef(_, AnyClass, _), _) => false // avoid some warnings when Nothing/Any are on the other side case (_, TypeRef(_, NothingClass, _)) => false case (pt1: PolyType, pt2: PolyType) => isPolySubType(pt1, pt2) // @assume both .isHigherKinded (both normalized to PolyType) case (_: PolyType, MethodType(ps, _)) if ps exists (_.tpe.isWildcard) => false // don't warn on HasMethodMatching on right hand side case _ => // @assume !(both .isHigherKinded) thus cannot be subtypes def tp_s(tp: Type): String = f"$tp%-20s ${util.shortClassOfInstance(tp)}%s" devWarning(s"HK subtype check on $tp1 and $tp2, but both don't normalize to polytypes:\\n tp1=${tp_s(ntp1)}\\n tp2=${tp_s(ntp2)}") false } ( (tp1.typeSymbol eq NothingClass) // @M Nothing is subtype of every well-kinded type || (tp2.typeSymbol eq AnyClass) // @M Any is supertype of every well-kinded type (@PP: is it? What about continuations plugin?) || isSub(tp1.normalize, tp2.normalize) && annotationsConform(tp1, tp2) // @M! normalize reduces higher-kinded case to PolyType's ) } /** Does type `tp1` conform to `tp2`? */ private def isSubType2(tp1: Type, tp2: Type, depth: Depth): Boolean = { def retry(lhs: Type, rhs: Type) = ((lhs ne tp1) || (rhs ne tp2)) && isSubType(lhs, rhs, depth) if (isSingleType(tp1) && isSingleType(tp2) || isConstantType(tp1) && isConstantType(tp2)) return (tp1 =:= tp2) || isThisAndSuperSubtype(tp1, tp2) || retry(tp1.underlying, tp2) if (tp1.isHigherKinded || tp2.isHigherKinded) return isHKSubType(tp1, tp2, depth) /* First try, on the right: * - unwrap Annotated types, BoundedWildcardTypes, * - bind TypeVars on the right, if lhs is not Annotated nor BoundedWildcard * - handle common cases for first-kind TypeRefs on both sides as a fast path. */ def firstTry = tp2 match { // fast path: two typerefs, none of them HK case tr2: TypeRef => tp1 match { case tr1: TypeRef => // TODO - dedicate a method to TypeRef/TypeRef subtyping. // These typerefs are pattern matched up and down far more // than is necessary. val sym1 = tr1.sym val sym2 = tr2.sym val pre1 = tr1.pre val pre2 = tr2.pre (((if (sym1 eq sym2) phase.erasedTypes || sym1.owner.hasPackageFlag || isSubType(pre1, pre2, depth) else (sym1.name == sym2.name && !sym1.isModuleClass && !sym2.isModuleClass && (isUnifiable(pre1, pre2) || isSameSpecializedSkolem(sym1, sym2, pre1, pre2) || sym2.isAbstractType && isSubPre(pre1, pre2, sym2)))) && isSubArgs(tr1.args, tr2.args, sym1.typeParams, depth)) || sym2.isClass && { val base = tr1 baseType sym2 // During bootstrap, `base eq NoType` occurs about 2.5 times as often as `base ne NoType`. // The extra check seems like a worthwhile optimization (about 2.5M useless calls to isSubtype saved during that run). (base ne tr1) && (base ne NoType) && isSubType(base, tr2, depth) } || thirdTryRef(tr1, tr2)) case _ => secondTry } case AnnotatedType(_, _) => isSubType(tp1.withoutAnnotations, tp2.withoutAnnotations, depth) && annotationsConform(tp1, tp2) case BoundedWildcardType(bounds) => isSubType(tp1, bounds.hi, depth) case tv2 @ TypeVar(_, constr2) => tp1 match { case AnnotatedType(_, _) | BoundedWildcardType(_) => secondTry case _ => tv2.registerBound(tp1, isLowerBound = true) } case _ => secondTry } /* Second try, on the left: * - unwrap AnnotatedTypes, BoundedWildcardTypes, * - bind typevars, * - handle existential types by skolemization. */ def secondTry = tp1 match { case AnnotatedType(_, _) => isSubType(tp1.withoutAnnotations, tp2.withoutAnnotations, depth) && annotationsConform(tp1, tp2) case BoundedWildcardType(bounds) => isSubType(tp1.bounds.lo, tp2, depth) case tv @ TypeVar(_,_) => tv.registerBound(tp2, isLowerBound = false) case ExistentialType(_, _) => try { skolemizationLevel += 1 isSubType(tp1.skolemizeExistential, tp2, depth) } finally { skolemizationLevel -= 1 } case _ => thirdTry } def thirdTryRef(tp1: Type, tp2: TypeRef): Boolean = { val sym2 = tp2.sym def retry(lhs: Type, rhs: Type) = isSubType(lhs, rhs, depth) def abstractTypeOnRight(lo: Type) = isDifferentTypeConstructor(tp2, lo) && retry(tp1, lo) def classOnRight = ( if (isRawType(tp2)) retry(tp1, rawToExistential(tp2)) else if (sym2.isRefinementClass) retry(tp1, sym2.info) else fourthTry ) sym2 match { case SingletonClass => tp1.isStable || fourthTry case _: ClassSymbol => classOnRight case _: TypeSymbol if sym2.isDeferred => abstractTypeOnRight(tp2.bounds.lo) || fourthTry case _: TypeSymbol => retry(normalizePlus(tp1), normalizePlus(tp2)) case _ => fourthTry } } /* Third try, on the right: * - decompose refined types. * - handle typerefs and existentials. * - handle left+right method types, polytypes, typebounds */ def thirdTry = tp2 match { case tr2: TypeRef => thirdTryRef(tp1, tr2) case rt2: RefinedType => (rt2.parents forall (isSubType(tp1, _, depth))) && (rt2.decls forall (specializesSym(tp1, _, depth))) case et2: ExistentialType => et2.withTypeVars(isSubType(tp1, _, depth), depth) || fourthTry case mt2: MethodType => tp1 match { case mt1 @ MethodType(params1, res1) => val params2 = mt2.params val res2 = mt2.resultType (sameLength(params1, params2) && mt1.isImplicit == mt2.isImplicit && matchingParams(params1, params2, mt1.isJava, mt2.isJava) && isSubType(res1.substSym(params1, params2), res2, depth)) // TODO: if mt1.params.isEmpty, consider NullaryMethodType? case _ => false } case pt2 @ NullaryMethodType(_) => tp1 match { // TODO: consider MethodType mt for which mt.params.isEmpty?? case pt1 @ NullaryMethodType(_) => isSubType(pt1.resultType, pt2.resultType, depth) case _ => false } case TypeBounds(lo2, hi2) => tp1 match { case TypeBounds(lo1, hi1) => isSubType(lo2, lo1, depth) && isSubType(hi1, hi2, depth) case _ => false } case _ => fourthTry } /* Fourth try, on the left: * - handle typerefs, refined types, and singleton types. */ def fourthTry = { def retry(lhs: Type, rhs: Type) = ((tp1 ne lhs) || (tp2 ne rhs)) && isSubType(lhs, rhs, depth) def abstractTypeOnLeft(hi: Type) = isDifferentTypeConstructor(tp1, hi) && retry(hi, tp2) tp1 match { case tr1 @ TypeRef(pre1, sym1, _) => def nullOnLeft = tp2 match { case TypeRef(_, sym2, _) => sym1 isBottomSubClass sym2 case _ => isSingleType(tp2) && retry(tp1, tp2.widen) } sym1 match { case NothingClass => true case NullClass => nullOnLeft case _: ClassSymbol if isRawType(tp1) => retry(normalizePlus(tp1), normalizePlus(tp2)) case _: ClassSymbol if sym1.isModuleClass => retry(normalizePlus(tp1), normalizePlus(tp2)) case _: ClassSymbol if sym1.isRefinementClass => retry(sym1.info, tp2) case _: TypeSymbol if sym1.isDeferred => abstractTypeOnLeft(tp1.bounds.hi) case _: TypeSymbol => retry(normalizePlus(tp1), normalizePlus(tp2)) case _ => false } case RefinedType(parents, _) => parents exists (retry(_, tp2)) case _: SingletonType => retry(tp1.underlying, tp2) case _ => false } } firstTry } def isWeakSubType(tp1: Type, tp2: Type) = tp1.dealiasWiden match { case TypeRef(_, sym1, _) if isNumericValueClass(sym1) => tp2.deconst.dealias match { case TypeRef(_, sym2, _) if isNumericValueClass(sym2) => isNumericSubClass(sym1, sym2) case tv2 @ TypeVar(_, _) => tv2.registerBound(tp1, isLowerBound = true, isNumericBound = true) case _ => isSubType(tp1, tp2) } case tv1 @ TypeVar(_, _) => tp2.deconst.dealias match { case TypeRef(_, sym2, _) if isNumericValueClass(sym2) => tv1.registerBound(tp2, isLowerBound = false, isNumericBound = true) case _ => isSubType(tp1, tp2) } case _ => isSubType(tp1, tp2) } def isNumericSubType(tp1: Type, tp2: Type) = ( isNumericSubClass(primitiveBaseClass(tp1.dealiasWiden), primitiveBaseClass(tp2.dealias)) ) /** If the given type has a primitive class among its base classes, * the symbol of that class. Otherwise, NoSymbol. */ private def primitiveBaseClass(tp: Type): Symbol = { @tailrec def loop(bases: List[Symbol]): Symbol = bases match { case Nil => NoSymbol case x :: xs => if (isPrimitiveValueClass(x)) x else loop(xs) } loop(tp.baseClasses) } }
felixmulder/scala
src/reflect/scala/reflect/internal/tpe/TypeComparers.scala
Scala
bsd-3-clause
26,607
package almhirt.herder.herdingdogs import scalaz.Validation.FlatMap._ import akka.actor._ import almhirt.common._ import almhirt.context._ import almhirt.akkax.ComponentId import almhirt.herder._ import almhirt.problem.{ Severity } import akka.actor.ActorRef object RejectedCommandsHerdingDog { import com.typesafe.config.Config def props(implicit ctx: AlmhirtContext): AlmValidation[Props] = { import almhirt.configuration._ val configPath = "almhirt.herder.herding-dogs.rejected-commands" for { section ← ctx.config.v[Config](configPath) historySize ← section.v[Int]("history-size") unwrapFailures ← section.v[Boolean]("unwrap-failures") downgradeCommandRepresentation ← section.v[Boolean]("downgrade-command-representations") } yield Props(new RejectedCommandsHerdingDog(historySize, unwrapFailures, downgradeCommandRepresentation)) } val actorname = "rejected-commands-herdingdog" } private[almhirt] class RejectedCommandsHerdingDog(historySize: Int, unwrapFailures: Boolean, downgradeCommandRepresentation: Boolean)(implicit override val almhirtContext: AlmhirtContext) extends Actor with HasAlmhirtContext with ActorLogging { import HerderMessages.CommandMessages._ implicit val executor = almhirtContext.futuresContext implicit object GetSev extends GetsSeverity[RejectedCommandsEntry] { def get(from: RejectedCommandsEntry): Severity = from._3 } val history = new MutableBadThingsHistories[ComponentId, RejectedCommandsEntry](historySize) def receiveRunning: Receive = { case RejectedCommand(componentId, commandRepr, severity, cause, timestamp) ⇒ history.add(componentId, (if(downgradeCommandRepresentation) commandRepr.downgradeToIdAndType else commandRepr, if (unwrapFailures) cause.unwrap() else cause, severity, timestamp)) case ReportRejectedCommands ⇒ val missed = history.allReversed.sorted sender() ! RejectedCommands(missed) case ReportRejectedCommandsFor(componentId) ⇒ sender() ! ReportedRejectedCommandsFor(componentId, history getImmutableReversed componentId) } override def receive: Receive = receiveRunning }
chridou/almhirt
almhirt-core/src/main/scala/almhirt/herder/herdingdogs/RejectedCommandsHerdingDog.scala
Scala
apache-2.0
2,177
package io.getquill import io.getquill.context.Context // Testing we are passing type params explicitly into AsyncContext, otherwise // this file will fail to compile trait BaseExtensions { val context: Context[PostgresDialect, _] } trait AsyncExtensions extends BaseExtensions { override val context: PostgresAsyncContext[_] }
getquill/quill
quill-async-postgres/src/test/scala/io/getquill/TypeParamExtensionTest.scala
Scala
apache-2.0
336
package org.jetbrains.plugins.scala package lang package psi package api package toplevel import javax.swing.Icon import com.intellij.extapi.psi.StubBasedPsiElementBase import com.intellij.navigation.ItemPresentation import com.intellij.openapi.editor.colors.TextAttributesKey import com.intellij.psi._ import com.intellij.psi.search.{LocalSearchScope, SearchScope} import com.intellij.psi.stubs.NamedStub import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.plugins.scala.extensions.PsiElementExt import org.jetbrains.plugins.scala.icons.Icons import org.jetbrains.plugins.scala.lang.psi.api.base.patterns.ScCaseClause import org.jetbrains.plugins.scala.lang.psi.api.expr._ import org.jetbrains.plugins.scala.lang.psi.api.statements.params.ScClassParameter import org.jetbrains.plugins.scala.lang.psi.api.toplevel.templates.ScTemplateBody import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef._ import org.jetbrains.plugins.scala.lang.psi.impl.ScalaPsiElementFactory.createIdentifier import org.jetbrains.plugins.scala.lang.psi.impl.toplevel.synthetic.JavaIdentifier import org.jetbrains.plugins.scala.lang.refactoring.util.ScalaNamesUtil import org.jetbrains.plugins.scala.macroAnnotations.{Cached, ModCount} trait ScNamedElement extends ScalaPsiElement with PsiNameIdentifierOwner with NavigatablePsiElement { @Cached(ModCount.anyScalaPsiModificationCount, this) def name: String = { this match { case st: StubBasedPsiElementBase[_] => st.getGreenStub match { case namedStub: NamedStub[_] => namedStub.getName case _ => nameInner } case _ => nameInner } } def name_=(it: String) { setName(it) } def nameInner: String = nameId.getText @Cached(ModCount.anyScalaPsiModificationCount, this) def nameContext: PsiElement = this.withParentsInFile .find(ScalaPsiUtil.isNameContext) .orNull override def getTextOffset: Int = nameId.getTextRange.getStartOffset override def getName: String = ScalaNamesUtil.toJavaName(name) def nameId: PsiElement override def getNameIdentifier: PsiIdentifier = if (nameId != null) new JavaIdentifier(nameId) else null override def setName(name: String): PsiElement = { val id = nameId.getNode val parent = id.getTreeParent val newId = createIdentifier(name) parent.replaceChild(id, newId) this } override def getPresentation: ItemPresentation = { val clazz: ScTemplateDefinition = nameContext.getParent match { case _: ScTemplateBody | _: ScEarlyDefinitions => PsiTreeUtil.getParentOfType(this, classOf[ScTemplateDefinition], true) case _ if this.isInstanceOf[ScClassParameter] => PsiTreeUtil.getParentOfType(this, classOf[ScTemplateDefinition], true) case _ => null } val parentMember: ScMember = PsiTreeUtil.getParentOfType(this, classOf[ScMember], false) new ItemPresentation { def getPresentableText: String = name def getTextAttributesKey: TextAttributesKey = null def getLocationString: String = clazz match { case _: ScTypeDefinition => "(" + clazz.qualifiedName + ")" case _: ScNewTemplateDefinition => "(<anonymous>)" case _ => "" } override def getIcon(open: Boolean): Icon = parentMember match {case mem: ScMember => mem.getIcon(0) case _ => null} } } override def getIcon(flags: Int): Icon = nameContext match { case null => null case _: ScCaseClause => Icons.PATTERN_VAL case x => x.getIcon(flags) } abstract override def getUseScope: SearchScope = { ScalaPsiUtil.intersectScopes(super.getUseScope, nameContext match { case member: ScMember if member != this => Some(member.getUseScope) case caseClause: ScCaseClause => Some(new LocalSearchScope(caseClause)) case elem @ (_: ScEnumerator | _: ScGenerator) => Option(PsiTreeUtil.getContextOfType(elem, true, classOf[ScForStatement])) .orElse(Option(PsiTreeUtil.getContextOfType(elem, true, classOf[ScBlock], classOf[ScMember]))) .map(new LocalSearchScope(_)) case _ => None }) } }
loskutov/intellij-scala
src/org/jetbrains/plugins/scala/lang/psi/api/toplevel/ScNamedElement.scala
Scala
apache-2.0
4,151
package eventstore package cluster import org.joda.time.{ DateTimeZone, DateTime } import org.joda.time.format.{ DateTimeFormat => JodaFormat, DateTimeFormatter } import spray.json._ import scala.util.{ Failure, Try, Success } object ClusterProtocol extends DefaultJsonProtocol { implicit object UuidFormat extends JsonFormat[Uuid] { def write(x: Uuid) = JsString(x.toString) def read(json: JsValue) = json match { case JsString(x) => x.uuid case _ => deserializationError("Uuid expected") } } implicit object DateTimeFormat extends JsonFormat[DateTime] { val formats = List( JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'"), JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSSSSSS'Z'"), JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss'Z'"), JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSSSS'Z'"), JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSSS'Z'"), JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"), JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SS'Z'"), JodaFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.S'Z'")) def write(x: DateTime) = JsString(x.toString(formats.head)) def read(json: JsValue) = json match { case JsString(x) => def loop(h: DateTimeFormatter, t: List[DateTimeFormatter]): DateTime = Try(h.parseDateTime(x)) match { case Success(x) => x.withZoneRetainFields(DateTimeZone.UTC) case Failure(x) => if (t.nonEmpty) loop(t.head, t.tail) else throw x } loop(formats.head, formats.tail) case _ => deserializationError("Date expected") } } implicit object NodeStateFormat extends JsonFormat[NodeState] { def write(obj: NodeState) = JsString(obj.toString) def read(json: JsValue) = json match { case JsString(x) => NodeState(x) case _ => deserializationError("NodeState expected") } } implicit object MemberInfoFormat extends JsonFormat[MemberInfo] { private val MappingFormat = jsonFormat21(Mapping) def read(json: JsValue) = { val m = MappingFormat.read(json) MemberInfo( instanceId = m.instanceId, timestamp = m.timeStamp, state = m.state, isAlive = m.isAlive, internalTcp = m.internalTcpIp :: m.internalTcpPort, externalTcp = m.externalTcpIp :: m.externalTcpPort, internalSecureTcp = m.internalTcpIp :: m.internalSecureTcpPort, externalSecureTcp = m.externalTcpIp :: m.externalSecureTcpPort, internalHttp = m.internalHttpIp :: m.internalHttpPort, externalHttp = m.externalHttpIp :: m.externalHttpPort, lastCommitPosition = m.lastCommitPosition, writerCheckpoint = m.writerCheckpoint, chaserCheckpoint = m.chaserCheckpoint, epochPosition = m.epochPosition, epochNumber = m.epochNumber, epochId = m.epochId, nodePriority = m.nodePriority) } def write(x: MemberInfo) = { val m = Mapping( instanceId = x.instanceId, timeStamp = x.timestamp, state = x.state, isAlive = x.isAlive, internalTcpIp = x.internalTcp.getHostString, internalTcpPort = x.internalTcp.getPort, internalSecureTcpPort = x.internalSecureTcp.getPort, externalTcpIp = x.externalTcp.getHostString, externalTcpPort = x.externalTcp.getPort, externalSecureTcpPort = x.externalSecureTcp.getPort, internalHttpIp = x.internalHttp.getHostString, internalHttpPort = x.internalHttp.getPort, externalHttpIp = x.externalHttp.getHostString, externalHttpPort = x.externalHttp.getPort, lastCommitPosition = x.lastCommitPosition, writerCheckpoint = x.writerCheckpoint, chaserCheckpoint = x.chaserCheckpoint, epochPosition = x.epochPosition, epochNumber = x.epochNumber, epochId = x.epochId, nodePriority = x.nodePriority) MappingFormat.write(m) } case class Mapping( instanceId: Uuid, timeStamp: DateTime, state: NodeState, isAlive: Boolean, internalTcpIp: String, internalTcpPort: Int, internalSecureTcpPort: Int, externalTcpIp: String, externalTcpPort: Int, externalSecureTcpPort: Int, internalHttpIp: String, internalHttpPort: Int, externalHttpIp: String, externalHttpPort: Int, lastCommitPosition: Long, writerCheckpoint: Long, chaserCheckpoint: Long, epochPosition: Long, epochNumber: Int, epochId: Uuid, nodePriority: Int) } implicit object ClusterInfoFormat extends RootJsonFormat[ClusterInfo] { private val MappingFormat = jsonFormat3(Mapping.apply) def read(json: JsValue) = { val m = MappingFormat.read(json) ClusterInfo( serverAddress = m.serverIp :: m.serverPort, members = m.members) } def write(x: ClusterInfo) = { val m = Mapping( members = x.members, serverIp = x.serverAddress.getHostString, serverPort = x.serverAddress.getPort) MappingFormat.write(m) } private case class Mapping(members: List[MemberInfo], serverIp: String, serverPort: Int) } }
pawelkaczor/EventStore.JVM
src/main/scala/eventstore/cluster/ClusterProtocol.scala
Scala
bsd-3-clause
5,222
package view import java.util.Date import org.specs2.mutable._ import service.RequestCache import model.Account import service.SystemSettingsService.SystemSettings import twirl.api.Html class AvatarImageProviderSpec extends Specification { implicit val context = app.Context("", None, "", null) "getAvatarImageHtml" should { "show Gravatar image for no image account if gravatar integration is enabled" in { val provider = new AvatarImageProviderImpl(Some(createAccount(None)), createSystemSettings(true)) provider.toHtml("user", 20).toString mustEqual "<img src=\\"https://www.gravatar.com/avatar/d41d8cd98f00b204e9800998ecf8427e?s=20\\" class=\\"avatar\\" style=\\"width: 20px; height: 20px;\\" />" } "show uploaded image even if gravatar integration is enabled" in { val provider = new AvatarImageProviderImpl(Some(createAccount(Some("icon.png"))), createSystemSettings(true)) provider.toHtml("user", 20).toString mustEqual "<img src=\\"/user/_avatar\\" class=\\"avatar\\" style=\\"width: 20px; height: 20px;\\" />" } "show local image for no image account if gravatar integration is disabled" in { val provider = new AvatarImageProviderImpl(Some(createAccount(None)), createSystemSettings(false)) provider.toHtml("user", 20).toString mustEqual "<img src=\\"/user/_avatar\\" class=\\"avatar\\" style=\\"width: 20px; height: 20px;\\" />" } "show Gravatar image for specified mail address if gravatar integration is enabled" in { val provider = new AvatarImageProviderImpl(None, createSystemSettings(true)) provider.toHtml("user", 20, "[email protected]").toString mustEqual "<img src=\\"https://www.gravatar.com/avatar/4712f9b0e63f56ad952ad387eaa23b9c?s=20\\" class=\\"avatar\\" style=\\"width: 20px; height: 20px;\\" />" } "show unknown image for unknown user if gravatar integration is enabled" in { val provider = new AvatarImageProviderImpl(None, createSystemSettings(true)) provider.toHtml("user", 20).toString mustEqual "<img src=\\"/_unknown/_avatar\\" class=\\"avatar\\" style=\\"width: 20px; height: 20px;\\" />" } "show unknown image for specified mail address if gravatar integration is disabled" in { val provider = new AvatarImageProviderImpl(None, createSystemSettings(false)) provider.toHtml("user", 20, "[email protected]").toString mustEqual "<img src=\\"/_unknown/_avatar\\" class=\\"avatar\\" style=\\"width: 20px; height: 20px;\\" />" } "add tooltip if it's enabled" in { val provider = new AvatarImageProviderImpl(None, createSystemSettings(false)) provider.toHtml("user", 20, "[email protected]", true).toString mustEqual "<img src=\\"/_unknown/_avatar\\" class=\\"avatar\\" style=\\"width: 20px; height: 20px;\\" data-toggle=\\"tooltip\\" title=\\"user\\"/>" } } private def createAccount(image: Option[String]) = Account( userName = "user", fullName = "user@localhost", mailAddress = "", password = "", isAdmin = false, url = None, registeredDate = new Date(), updatedDate = new Date(), lastLoginDate = None, image = image, isGroupAccount = false, isRemoved = false) private def createSystemSettings(useGravatar: Boolean) = SystemSettings( allowAccountRegistration = false, gravatar = useGravatar, notification = false, smtp = None, ldapAuthentication = false, ldap = None) /** * Adapter to test AvatarImageProviderImpl. */ class AvatarImageProviderImpl(account: Option[Account], settings: SystemSettings) extends AvatarImageProvider with RequestCache { def toHtml(userName: String, size: Int, mailAddress: String = "", tooltip: Boolean = false) (implicit context: app.Context): Html = getAvatarImageHtml(userName, size, mailAddress, tooltip) override def getAccountByMailAddress(mailAddress: String)(implicit context: app.Context): Option[Account] = account override def getAccountByUserName(userName: String)(implicit context: app.Context): Option[Account] = account override def getSystemSettings()(implicit context: app.Context): SystemSettings = settings } }
loveshell/gitbucket
src/test/scala/view/AvatarImageProviderSpec.scala
Scala
apache-2.0
4,358
package object scalaFP extends Base
aaronvargo/scalaFP
base/src/main/scala/package.scala
Scala
bsd-3-clause
36
package org.jetbrains.plugins.cbt.settings import com.intellij.openapi.externalSystem.service.settings.{AbstractExternalProjectSettingsControl, AbstractExternalSystemConfigurable} import com.intellij.openapi.externalSystem.util.{ExternalSystemSettingsControl, PaintAwarePanel} import com.intellij.openapi.project.Project import org.jetbrains.plugins.cbt.project.CbtProjectSystem import org.jetbrains.plugins.cbt.project.settings.{CbtProjectSettings, CbtProjectSettingsListener, CbtSystemSettings, CbtSystemSettingsControl} class CbtExternalSystemConfigurable(project: Project) extends AbstractExternalSystemConfigurable[CbtProjectSettings, CbtProjectSettingsListener, CbtSystemSettings](project, CbtProjectSystem.Id) { override def newProjectSettings(): CbtProjectSettings = new CbtProjectSettings override def createSystemSettingsControl(settings: CbtSystemSettings): CbtSystemSettingsControl = new CbtSystemSettingsControl(settings) override def createProjectSettingsControl(settings: CbtProjectSettings): AbstractExternalProjectSettingsControl[CbtProjectSettings] = new AbstractExternalProjectSettingsControl[CbtProjectSettings](settings) { override def applyExtraSettings(settings: CbtProjectSettings): Unit = {} override def resetExtraSettings(isDefaultModuleCreation: Boolean): Unit = {} override def fillExtraControls(content: PaintAwarePanel, indentLevel: Int): Unit = {} override def isExtraSettingModified: Boolean = false override def validate(settings: CbtProjectSettings): Boolean = true } override def getId: String = "cbt.project.settings.configurable" }
triplequote/intellij-scala
cbt/src/org/jetbrains/plugins/cbt/settings/CbtExternalSystemConfigurable.scala
Scala
apache-2.0
1,637
package com.twitter.example import java.net.InetSocketAddress import org.apache.thrift.protocol.TBinaryProtocol import com.twitter.finagle.builder.ClientBuilder import com.twitter.finagle.Service import com.twitter.finagle.thrift.{ThriftClientFramedCodec, ThriftClientRequest} import thrift.EchoService object EchoClient { def main(args: Array[String]) { // Create a raw Thrift client service. This implements the // ThriftClientRequest => Future[Array[Byte]] interface. val service: Service[ThriftClientRequest, Array[Byte]] = ClientBuilder() .hosts(new InetSocketAddress(EchoServer.port)) .codec(ThriftClientFramedCodec()) .hostConnectionLimit(1) .build() // Wrap the raw Thrift service in a Client decorator. The client // provides a convenient procedural interface for accessing the Thrift // server. val client = new EchoService.ServiceToClient(service, new TBinaryProtocol.Factory()) client.echo("hello") onSuccess { response => println("Received response: " + response) } ensure { service.release() } } }
twitter/iago
examples/echo/src/main/scala/com/twitter/example/EchoClient.scala
Scala
apache-2.0
1,098
package com.github.j5ik2o.wicket.pages import org.apache.wicket.ajax.AjaxRequestTarget import org.apache.wicket.ajax.markup.html.AjaxFallbackLink import org.apache.wicket.markup.html.basic.Label import org.apache.wicket.model.Model class AjaxCounterPage extends BasePage { val model = new Model[java.lang.Integer]() { private var counter = 0 override def getObject(): java.lang.Integer = { counter += 1 counter } } val label = new Label("counter", model) label.setOutputMarkupId(true) add(new AjaxFallbackLink("link") { override def onClick(target: AjaxRequestTarget): Unit = { if (target != null) { target.add(label) } // add the components that need to be updated to // the target } }) add(label) }
j5ik2o/scala-wicket-sample
application/src/main/scala/com/github/j5ik2o/wicket/pages/AjaxCounterPage.scala
Scala
mit
787
package fpgatidbits.dma import Chisel._ import fpgatidbits.ocm._ class RespDeinterleaverIF(numPipes: Int, p: MemReqParams) extends Bundle { // interleaved responses in val rspIn = Decoupled(new GenericMemoryResponse(p)).flip // deinterleaved responses out val rspOut = Vec.fill(numPipes) {Decoupled(new GenericMemoryResponse(p))} // number of decode errors (ID width no matching pipe) val decodeErrors = UInt(OUTPUT, width = 32) override def clone = { new RespDeinterleaverIF(numPipes, p).asInstanceOf[this.type] } } class QueuedDeinterleaver(numPipes: Int, p: MemReqParams, n: Int, routeFxn: GenericMemoryResponse => UInt = {x: GenericMemoryResponse => x.channelID} ) extends Module { val io = new RespDeinterleaverIF(numPipes,p) val deint = Module(new RespDeinterleaver(numPipes, p, routeFxn)).io deint.rspIn <> io.rspIn io.decodeErrors := deint.decodeErrors for(i <- 0 until numPipes) { val rspQ = Module(new FPGAQueue(new GenericMemoryResponse(p), n)).io rspQ.deq <> io.rspOut(i) rspQ.enq <> deint.rspOut(i) } } class RespDeinterleaver(numPipes: Int, p: MemReqParams, routeFxn: GenericMemoryResponse => UInt = {x: GenericMemoryResponse => x.channelID} ) extends Module { val io = new RespDeinterleaverIF(numPipes, p) val regDecodeErrors = Reg(init = UInt(0, 32)) // TODO the current implementation is likely to cause timing problems // due to high-fanout signals and combinational paths // - to avoid high-fanout signals: implement decoding as e.g shiftreg // - to avoid combinational paths, pipeline the deinterleaver for(i <- 0 until numPipes) { io.rspOut(i).bits := io.rspIn.bits io.rspOut(i).valid := Bool(false) } io.rspIn.ready := Bool(false) io.decodeErrors := regDecodeErrors val destPipe = routeFxn(io.rspIn.bits) val invalidChannel = (destPipe >= UInt(numPipes)) val canProceed = io.rspIn.valid && io.rspOut(destPipe).ready when (invalidChannel) { // do not let the entire pipe stall because head of line has invalid dest // increment error counter and move on regDecodeErrors := regDecodeErrors + UInt(1) io.rspIn.ready := Bool(true) printf("RespDeinterleaver decode error! chanID = %d dest = %d \\n", io.rspIn.bits.channelID, destPipe ) } .elsewhen (canProceed) { io.rspIn.ready := Bool(true) io.rspOut(destPipe).valid := Bool(true) } }
maltanar/fpga-tidbits
src/main/scala/fpgatidbits/dma/RespDeinterleaver.scala
Scala
bsd-2-clause
2,393
/* Copyright 2009 David Hall, Daniel Ramage Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package scalanlp.serialization; import org.scalatest.FunSuite; import org.scalatest.junit.JUnitRunner; import org.junit.runner.RunWith; package typedexamples { case class MyCaseClass1(b : String); object MyCaseClass1 extends TypedCompanion1[String,MyCaseClass1] { prepare(); } case class MyCaseClass2(a : Int, b : String) object MyCaseClass2 extends TypedCompanion2[Int,String,MyCaseClass2] { prepare(); } case class MyCompoundCaseClass1(a : (Int,Double)); object MyCompoundCaseClass1 extends TypedCompanion1[(Int,Double),MyCompoundCaseClass1] { prepare(); } case class MyCompoundCaseClass2(a : Int, b : MyCaseClass2) object MyCompoundCaseClass2 extends TypedCompanion2[Int,MyCaseClass2,MyCompoundCaseClass2] { prepare(); } case class MyCompoundCaseClass3(a : List[Double]); object MyCompoundCaseClass3 extends TypedCompanion1[List[Double],MyCompoundCaseClass3] { prepare(); } trait SubtypedRoot; object SubtypedRoot extends SubtypedCompanion[SubtypedRoot] { prepare(); register[SubtypedOption1]("SubtypedOption1"); register[SubtypedOption2]("SubtypedOption2"); } case class SubtypedOption1(value : Int) extends SubtypedRoot; object SubtypedOption1 extends TypedCompanion1[Int,SubtypedOption1] { prepare(); } case class SubtypedOption2(str : String) extends SubtypedRoot; object SubtypedOption2 extends TypedCompanion1[String,SubtypedOption2] { prepare(); } } @RunWith(classOf[JUnitRunner]) class TypedCaseCompanionTest extends FunSuite { import typedexamples._; def loop[T:TextSerialization.ReadWritable](value : T) = { val string = TextSerialization.toString(value); val parsed = TextSerialization.fromString[T](string); assert(parsed === value, "Failure on "+string); } test("Check case class to and from string") { loop(MyCaseClass1("hi")); loop(MyCaseClass2(1,"hi")); loop(MyCompoundCaseClass1((1,2.0))); loop(MyCompoundCaseClass2(1,MyCaseClass2(2,"yo"))); loop(MyCompoundCaseClass3(List(1.0,2.0))); } test("Check SubtypedCompanion") { val o1 = SubtypedOption1(-1); val o2 = SubtypedOption2("hi"); loop(o1); loop(o2); assert(TextSerialization.fromString[SubtypedRoot](TextSerialization.toString(o1)) === o1); assert(TextSerialization.fromString[SubtypedRoot](TextSerialization.toString(o2)) === o2); } }
MLnick/scalanlp-core
data/src/test/scala/scalanlp/serialization/TypedCompanionTest.scala
Scala
apache-2.0
2,960
package circlepuzzles.geometry import circlepuzzles.math.FixedPoint /** * Angles that can specify rotations. * @param radians Value of the angle in radians. Must be in the range [0,2*pi). */ class Angle(val radians: FixedPoint) { /** * The sine of this angle. * @return `sin(radians)`. */ def sin: FixedPoint = FixedPoint.sin(radians) /** * The cosine of this angle. * @return `cos(radians)`. */ def cos: FixedPoint = FixedPoint.cos(radians) /** * Angle addition. * @param that Angle to add * @return Sum of the angles `this + that`. */ def +(that: Angle): Angle = { new Angle(FixedPoint.mod2Pi(radians + that.radians)) } /** * The explement of this angle, i.e. the angle that can be added to this to give a full circle. * @return Explement of this angle. */ def explement: Angle = { new Angle(FixedPoint.TwoPi - radians) } /** * The supplement of this angle, i.e. the angle that can be added to this to give a half circle. * @return Supplement of this angle. */ def supplement: Angle = { new Angle(FixedPoint.mod2Pi(FixedPoint.Pi - radians)) } /** * Memoize this angle. * @return A memoized angle equivalent to `this`. */ def memoized: MemoizedAngle = { new MemoizedAngle(radians) } /** * Tests if `that` is an equal `Angle`. Two angles are equal if and only if their values in radians are equal. * @param that Object to compare to. * @return True if and only if `this` and `that` are equal angles. */ override def equals(that: Any): Boolean = { that match { case thatAngle: Angle => radians == thatAngle.radians case _ => false } } /** * Returns a hash code that satisfies the [[Object]] contract, which is to say that the hash depends only on * `radians`. * @return A hash code depending only on `radians`. */ override def hashCode: Int = radians.hashCode /** * Returns a decimal representation of this angle's measure, in radians. * @return A string representation of this angle. */ override def toString: String = s"Angle($radians)" } /** * Angles that memoize the corresponding sine and cosine values. * @param radians Value of the angle in radians. Must be in the range `[0,2*pi)`. */ class MemoizedAngle(radians: FixedPoint) extends Angle(radians) { /** * The sine of this angle. Memoized. */ override val sin = super.sin /** * The cosine of this angle. Memoized. */ override val cos = super.cos override def memoized: MemoizedAngle = this }
wkretschmer/CirclePuzzles
src/main/scala/circlepuzzles/geometry/Angle.scala
Scala
mit
2,603
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.spark.sql.execution import org.apache.spark.sql.SaveMode import org.apache.spark.sql.catalyst.{FunctionIdentifier, TableIdentifier} import org.apache.spark.sql.catalyst.analysis.{AnalysisTest, UnresolvedAlias, UnresolvedAttribute, UnresolvedRelation, UnresolvedStar} import org.apache.spark.sql.catalyst.catalog.{BucketSpec, CatalogStorageFormat, CatalogTable, CatalogTableType} import org.apache.spark.sql.catalyst.expressions.{Ascending, Concat, SortOrder} import org.apache.spark.sql.catalyst.parser.ParseException import org.apache.spark.sql.catalyst.plans.logical.{LogicalPlan, Project, RepartitionByExpression, Sort} import org.apache.spark.sql.execution.command._ import org.apache.spark.sql.execution.datasources.{CreateTable, RefreshResource} import org.apache.spark.sql.internal.{HiveSerDe, SQLConf} import org.apache.spark.sql.types.{IntegerType, LongType, StringType, StructType} /** * Parser test cases for rules defined in [[SparkSqlParser]]. * * See [[org.apache.spark.sql.catalyst.parser.PlanParserSuite]] for rules * defined in the Catalyst module. */ class SparkSqlParserSuite extends AnalysisTest { val newConf = new SQLConf private lazy val parser = new SparkSqlParser(newConf) /** * Normalizes plans: * - CreateTable the createTime in tableDesc will replaced by -1L. */ override def normalizePlan(plan: LogicalPlan): LogicalPlan = { plan match { case CreateTable(tableDesc, mode, query) => val newTableDesc = tableDesc.copy(createTime = -1L) CreateTable(newTableDesc, mode, query) case _ => plan // Don't transform } } private def assertEqual(sqlCommand: String, plan: LogicalPlan): Unit = { val normalized1 = normalizePlan(parser.parsePlan(sqlCommand)) val normalized2 = normalizePlan(plan) comparePlans(normalized1, normalized2) } private def intercept(sqlCommand: String, messages: String*): Unit = { val e = intercept[ParseException](parser.parsePlan(sqlCommand)) messages.foreach { message => assert(e.message.contains(message)) } } test("refresh resource") { assertEqual("REFRESH prefix_path", RefreshResource("prefix_path")) assertEqual("REFRESH /", RefreshResource("/")) assertEqual("REFRESH /path///a", RefreshResource("/path///a")) assertEqual("REFRESH pat1h/112/_1a", RefreshResource("pat1h/112/_1a")) assertEqual("REFRESH pat1h/112/_1a/a-1", RefreshResource("pat1h/112/_1a/a-1")) assertEqual("REFRESH path-with-dash", RefreshResource("path-with-dash")) assertEqual("REFRESH \\'path with space\\'", RefreshResource("path with space")) assertEqual("REFRESH \\"path with space 2\\"", RefreshResource("path with space 2")) intercept("REFRESH a b", "REFRESH statements cannot contain") intercept("REFRESH a\\tb", "REFRESH statements cannot contain") intercept("REFRESH a\\nb", "REFRESH statements cannot contain") intercept("REFRESH a\\rb", "REFRESH statements cannot contain") intercept("REFRESH a\\r\\nb", "REFRESH statements cannot contain") intercept("REFRESH @ $a$", "REFRESH statements cannot contain") intercept("REFRESH ", "Resource paths cannot be empty in REFRESH statements") intercept("REFRESH", "Resource paths cannot be empty in REFRESH statements") } test("show functions") { assertEqual("show functions", ShowFunctionsCommand(None, None, true, true)) assertEqual("show all functions", ShowFunctionsCommand(None, None, true, true)) assertEqual("show user functions", ShowFunctionsCommand(None, None, true, false)) assertEqual("show system functions", ShowFunctionsCommand(None, None, false, true)) intercept("show special functions", "SHOW special FUNCTIONS") assertEqual("show functions foo", ShowFunctionsCommand(None, Some("foo"), true, true)) assertEqual("show functions foo.bar", ShowFunctionsCommand(Some("foo"), Some("bar"), true, true)) assertEqual("show functions 'foo\\\\\\\\.*'", ShowFunctionsCommand(None, Some("foo\\\\.*"), true, true)) intercept("show functions foo.bar.baz", "Unsupported function name") } test("describe function") { assertEqual("describe function bar", DescribeFunctionCommand(FunctionIdentifier("bar", database = None), isExtended = false)) assertEqual("describe function extended bar", DescribeFunctionCommand(FunctionIdentifier("bar", database = None), isExtended = true)) assertEqual("describe function foo.bar", DescribeFunctionCommand( FunctionIdentifier("bar", database = Some("foo")), isExtended = false)) assertEqual("describe function extended f.bar", DescribeFunctionCommand(FunctionIdentifier("bar", database = Some("f")), isExtended = true)) } private def createTableUsing( table: String, database: Option[String] = None, tableType: CatalogTableType = CatalogTableType.MANAGED, storage: CatalogStorageFormat = CatalogStorageFormat.empty, schema: StructType = new StructType, provider: Option[String] = Some("parquet"), partitionColumnNames: Seq[String] = Seq.empty, bucketSpec: Option[BucketSpec] = None, mode: SaveMode = SaveMode.ErrorIfExists, query: Option[LogicalPlan] = None): CreateTable = { CreateTable( CatalogTable( identifier = TableIdentifier(table, database), tableType = tableType, storage = storage, schema = schema, provider = provider, partitionColumnNames = partitionColumnNames, bucketSpec = bucketSpec ), mode, query ) } private def createTable( table: String, database: Option[String] = None, tableType: CatalogTableType = CatalogTableType.MANAGED, storage: CatalogStorageFormat = CatalogStorageFormat.empty.copy( inputFormat = HiveSerDe.sourceToSerDe("textfile").get.inputFormat, outputFormat = HiveSerDe.sourceToSerDe("textfile").get.outputFormat, serde = Some("org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe")), schema: StructType = new StructType, provider: Option[String] = Some("hive"), partitionColumnNames: Seq[String] = Seq.empty, comment: Option[String] = None, mode: SaveMode = SaveMode.ErrorIfExists, query: Option[LogicalPlan] = None): CreateTable = { CreateTable( CatalogTable( identifier = TableIdentifier(table, database), tableType = tableType, storage = storage, schema = schema, provider = provider, partitionColumnNames = partitionColumnNames, comment = comment ), mode, query ) } test("create table - schema") { assertEqual("CREATE TABLE my_tab(a INT COMMENT 'test', b STRING)", createTable( table = "my_tab", schema = (new StructType) .add("a", IntegerType, nullable = true, "test") .add("b", StringType) ) ) assertEqual("CREATE TABLE my_tab(a INT COMMENT 'test', b STRING) " + "PARTITIONED BY (c INT, d STRING COMMENT 'test2')", createTable( table = "my_tab", schema = (new StructType) .add("a", IntegerType, nullable = true, "test") .add("b", StringType) .add("c", IntegerType) .add("d", StringType, nullable = true, "test2"), partitionColumnNames = Seq("c", "d") ) ) assertEqual("CREATE TABLE my_tab(id BIGINT, nested STRUCT<col1: STRING,col2: INT>)", createTable( table = "my_tab", schema = (new StructType) .add("id", LongType) .add("nested", (new StructType) .add("col1", StringType) .add("col2", IntegerType) ) ) ) // Partitioned by a StructType should be accepted by `SparkSqlParser` but will fail an analyze // rule in `AnalyzeCreateTable`. assertEqual("CREATE TABLE my_tab(a INT COMMENT 'test', b STRING) " + "PARTITIONED BY (nested STRUCT<col1: STRING,col2: INT>)", createTable( table = "my_tab", schema = (new StructType) .add("a", IntegerType, nullable = true, "test") .add("b", StringType) .add("nested", (new StructType) .add("col1", StringType) .add("col2", IntegerType) ), partitionColumnNames = Seq("nested") ) ) intercept("CREATE TABLE my_tab(a: INT COMMENT 'test', b: STRING)", "no viable alternative at input") } test("SPARK-17328 Fix NPE with EXPLAIN DESCRIBE TABLE") { assertEqual("describe t", DescribeTableCommand(TableIdentifier("t"), Map.empty, isExtended = false)) assertEqual("describe table t", DescribeTableCommand(TableIdentifier("t"), Map.empty, isExtended = false)) assertEqual("describe table extended t", DescribeTableCommand(TableIdentifier("t"), Map.empty, isExtended = true)) assertEqual("describe table formatted t", DescribeTableCommand(TableIdentifier("t"), Map.empty, isExtended = true)) } test("describe query") { val query = "SELECT * FROM t" assertEqual("DESCRIBE QUERY " + query, DescribeQueryCommand(query, parser.parsePlan(query))) assertEqual("DESCRIBE " + query, DescribeQueryCommand(query, parser.parsePlan(query))) } test("describe table column") { assertEqual("DESCRIBE t col", DescribeColumnCommand( TableIdentifier("t"), Seq("col"), isExtended = false)) assertEqual("DESCRIBE t `abc.xyz`", DescribeColumnCommand( TableIdentifier("t"), Seq("abc.xyz"), isExtended = false)) assertEqual("DESCRIBE t abc.xyz", DescribeColumnCommand( TableIdentifier("t"), Seq("abc", "xyz"), isExtended = false)) assertEqual("DESCRIBE t `a.b`.`x.y`", DescribeColumnCommand( TableIdentifier("t"), Seq("a.b", "x.y"), isExtended = false)) assertEqual("DESCRIBE TABLE t col", DescribeColumnCommand( TableIdentifier("t"), Seq("col"), isExtended = false)) assertEqual("DESCRIBE TABLE EXTENDED t col", DescribeColumnCommand( TableIdentifier("t"), Seq("col"), isExtended = true)) assertEqual("DESCRIBE TABLE FORMATTED t col", DescribeColumnCommand( TableIdentifier("t"), Seq("col"), isExtended = true)) intercept("DESCRIBE TABLE t PARTITION (ds='1970-01-01') col", "DESC TABLE COLUMN for a specific partition is not supported") } test("analyze table statistics") { assertEqual("analyze table t compute statistics", AnalyzeTableCommand(TableIdentifier("t"), noscan = false)) assertEqual("analyze table t compute statistics noscan", AnalyzeTableCommand(TableIdentifier("t"), noscan = true)) assertEqual("analyze table t partition (a) compute statistics nOscAn", AnalyzePartitionCommand(TableIdentifier("t"), Map("a" -> None), noscan = true)) // Partitions specified assertEqual("ANALYZE TABLE t PARTITION(ds='2008-04-09', hr=11) COMPUTE STATISTICS", AnalyzePartitionCommand(TableIdentifier("t"), noscan = false, partitionSpec = Map("ds" -> Some("2008-04-09"), "hr" -> Some("11")))) assertEqual("ANALYZE TABLE t PARTITION(ds='2008-04-09', hr=11) COMPUTE STATISTICS noscan", AnalyzePartitionCommand(TableIdentifier("t"), noscan = true, partitionSpec = Map("ds" -> Some("2008-04-09"), "hr" -> Some("11")))) assertEqual("ANALYZE TABLE t PARTITION(ds='2008-04-09') COMPUTE STATISTICS noscan", AnalyzePartitionCommand(TableIdentifier("t"), noscan = true, partitionSpec = Map("ds" -> Some("2008-04-09")))) assertEqual("ANALYZE TABLE t PARTITION(ds='2008-04-09', hr) COMPUTE STATISTICS", AnalyzePartitionCommand(TableIdentifier("t"), noscan = false, partitionSpec = Map("ds" -> Some("2008-04-09"), "hr" -> None))) assertEqual("ANALYZE TABLE t PARTITION(ds='2008-04-09', hr) COMPUTE STATISTICS noscan", AnalyzePartitionCommand(TableIdentifier("t"), noscan = true, partitionSpec = Map("ds" -> Some("2008-04-09"), "hr" -> None))) assertEqual("ANALYZE TABLE t PARTITION(ds, hr=11) COMPUTE STATISTICS noscan", AnalyzePartitionCommand(TableIdentifier("t"), noscan = true, partitionSpec = Map("ds" -> None, "hr" -> Some("11")))) assertEqual("ANALYZE TABLE t PARTITION(ds, hr) COMPUTE STATISTICS", AnalyzePartitionCommand(TableIdentifier("t"), noscan = false, partitionSpec = Map("ds" -> None, "hr" -> None))) assertEqual("ANALYZE TABLE t PARTITION(ds, hr) COMPUTE STATISTICS noscan", AnalyzePartitionCommand(TableIdentifier("t"), noscan = true, partitionSpec = Map("ds" -> None, "hr" -> None))) intercept("analyze table t compute statistics xxxx", "Expected `NOSCAN` instead of `xxxx`") intercept("analyze table t partition (a) compute statistics xxxx", "Expected `NOSCAN` instead of `xxxx`") } test("analyze table column statistics") { intercept("ANALYZE TABLE t COMPUTE STATISTICS FOR COLUMNS", "") assertEqual("ANALYZE TABLE t COMPUTE STATISTICS FOR COLUMNS key, value", AnalyzeColumnCommand(TableIdentifier("t"), Option(Seq("key", "value")), allColumns = false)) // Partition specified - should be ignored assertEqual("ANALYZE TABLE t PARTITION(ds='2017-06-10') " + "COMPUTE STATISTICS FOR COLUMNS key, value", AnalyzeColumnCommand(TableIdentifier("t"), Option(Seq("key", "value")), allColumns = false)) // Partition specified should be ignored in case of COMPUTE STATISTICS FOR ALL COLUMNS assertEqual("ANALYZE TABLE t PARTITION(ds='2017-06-10') " + "COMPUTE STATISTICS FOR ALL COLUMNS", AnalyzeColumnCommand(TableIdentifier("t"), None, allColumns = true)) intercept("ANALYZE TABLE t COMPUTE STATISTICS FOR ALL COLUMNS key, value", "mismatched input 'key' expecting <EOF>") intercept("ANALYZE TABLE t COMPUTE STATISTICS FOR ALL", "missing 'COLUMNS' at '<EOF>'") } test("query organization") { // Test all valid combinations of order by/sort by/distribute by/cluster by/limit/windows val baseSql = "select * from t" val basePlan = Project(Seq(UnresolvedStar(None)), UnresolvedRelation(TableIdentifier("t"))) assertEqual(s"$baseSql distribute by a, b", RepartitionByExpression(UnresolvedAttribute("a") :: UnresolvedAttribute("b") :: Nil, basePlan, numPartitions = newConf.numShufflePartitions)) assertEqual(s"$baseSql distribute by a sort by b", Sort(SortOrder(UnresolvedAttribute("b"), Ascending) :: Nil, global = false, RepartitionByExpression(UnresolvedAttribute("a") :: Nil, basePlan, numPartitions = newConf.numShufflePartitions))) assertEqual(s"$baseSql cluster by a, b", Sort(SortOrder(UnresolvedAttribute("a"), Ascending) :: SortOrder(UnresolvedAttribute("b"), Ascending) :: Nil, global = false, RepartitionByExpression(UnresolvedAttribute("a") :: UnresolvedAttribute("b") :: Nil, basePlan, numPartitions = newConf.numShufflePartitions))) } test("pipeline concatenation") { val concat = Concat( Concat(UnresolvedAttribute("a") :: UnresolvedAttribute("b") :: Nil) :: UnresolvedAttribute("c") :: Nil ) assertEqual( "SELECT a || b || c FROM t", Project(UnresolvedAlias(concat) :: Nil, UnresolvedRelation(TableIdentifier("t")))) } test("database and schema tokens are interchangeable") { assertEqual("CREATE DATABASE foo", parser.parsePlan("CREATE SCHEMA foo")) assertEqual("DROP DATABASE foo", parser.parsePlan("DROP SCHEMA foo")) assertEqual("ALTER DATABASE foo SET DBPROPERTIES ('x' = 'y')", parser.parsePlan("ALTER SCHEMA foo SET DBPROPERTIES ('x' = 'y')")) assertEqual("DESC DATABASE foo", parser.parsePlan("DESC SCHEMA foo")) } }
LantaoJin/spark
sql/core/src/test/scala/org/apache/spark/sql/execution/SparkSqlParserSuite.scala
Scala
apache-2.0
16,577
package org.tearne.crosser.config import java.nio.file.Path import scala.util.Try import org.slf4j.LoggerFactory import com.typesafe.config.{ConfigFactory => TypesafeConfigFactory} import java.net.URL import scala.io.Source import com.typesafe.config.{Config => TypesafeConfig} object ConfigFactory { val log = LoggerFactory.getLogger(this.getClass()) def fromPath(path: Path): Config = { val tConf = TypesafeConfigFactory.parseFile(path.toFile()) fromTypesafeConfig(tConf) } def fromURL(url: String): Config = { val stream = new URL(url).openStream() val lines = Source.fromInputStream(stream).getLines val tConf = TypesafeConfigFactory.parseString(lines.next) assert(!lines.hasNext, "Expected only one line at config url") fromTypesafeConfig(tConf) } def fromTypesafeConfig(tConf: TypesafeConfig) = { Try{ log.debug("Try parsing human format config") new HumanConfig(tConf) }.getOrElse{ log.debug("Try parsing web format config") new WebConfig(tConf) } } }
tearne/Crosser
src/main/scala/org/tearne/crosser/config/ConfigFactory.scala
Scala
apache-2.0
1,005
package dotty.tools.dotc package core package tasty import dotty.tools.tasty.{TastyBuffer, TastyReader} import TastyBuffer.NameRef import Contexts._, Decorators._ import Names.{Name, TermName} import StdNames.nme import TastyUnpickler._ import util.Spans.offsetToInt import printing.Highlighting._ /** Reads the package and class name of the class contained in this TASTy */ class TastyClassName(bytes: Array[Byte]) { val unpickler: TastyUnpickler = new TastyUnpickler(bytes) import unpickler.{nameAtRef, unpickle} /** Returns a tuple with the package and class names */ def readName(): Option[(TermName, TermName)] = unpickle(new TreeSectionUnpickler) class TreeSectionUnpickler extends SectionUnpickler[(TermName, TermName)](TreePickler.sectionName) { import dotty.tools.tasty.TastyFormat._ def unpickle(reader: TastyReader, tastyName: NameTable): (TermName, TermName) = { import reader._ def readName() = { val idx = readNat() nameAtRef(NameRef(idx)) } def readNames(packageName: TermName): (TermName, TermName) = { val tag = readByte() if (tag >= firstLengthTreeTag) { val len = readNat() val end = currentAddr + len tag match { case TYPEDEF => val className = readName() goto(end) (packageName, className) case IMPORT | VALDEF => goto(end) readNames(packageName) case PACKAGE => readNames(packageName) } } else tag match { case TERMREFpkg | TYPEREFpkg => val subPackageName = readName() readNames(subPackageName) case _ => readNames(packageName) } } readNames(nme.EMPTY_PACKAGE) } } }
som-snytt/dotty
compiler/src/dotty/tools/dotc/core/tasty/TastyClassName.scala
Scala
apache-2.0
1,828
package io.taig.android.soap.operation import android.content.{ Intent, SharedPreferences } import android.os.Bundle import cats.syntax.either._ import io.circe.Decoder import io.circe.parser._ sealed trait reader[C] { def container: C def read[V: Decoder]( key: String ): Option[V] } object reader { @inline private def parse[V: Decoder]( json: String ): Option[V] = { Option( json ).flatMap { json ⇒ decode[V]( json ).toOption } } final case class bundle( container: Bundle ) extends reader[Bundle] { override def read[V: Decoder]( key: String ): Option[V] = { parse( container.getString( key ) ) } } final case class intent( container: Intent ) extends reader[Intent] { override def read[V: Decoder]( key: String ): Option[V] = { parse( container.getStringExtra( key ) ) } } final case class sharedPreferences( container: SharedPreferences ) extends reader[SharedPreferences] { override def read[V: Decoder]( key: String ): Option[V] = { parse( container.getString( key, null ) ) } } }
Taig/Soap
src/main/scala/io/taig/android/soap/operation/reader.scala
Scala
mit
1,165
package org.scalaide.core.internal.formatter import org.eclipse.jdt.internal.corext.fix.CodeFormatFix import org.eclipse.jdt.core.ICompilationUnit import org.eclipse.jdt.core.refactoring.CompilationUnitChange import org.eclipse.jdt.ui.cleanup.ICleanUpFix import org.eclipse.jface.text.Document import org.eclipse.jface.text.TextUtilities import org.eclipse.text.edits.MultiTextEdit import scalariform.formatter.ScalaFormatter import scalariform.parser.ScalaParserException import scala.tools.eclipse.contribution.weaving.jdt.ui.javaeditor.formatter.IFormatterCleanUpProvider import org.scalaide.util.eclipse.EclipseUtils.asEclipseTextEdit import org.eclipse.jdt.internal.ui.javaeditor.DocumentAdapter class ScalaFormatterCleanUpProvider extends IFormatterCleanUpProvider { def createCleanUp(cu: ICompilationUnit): ICleanUpFix = { val document = cu.getBuffer match { case adapter: DocumentAdapter => adapter.getDocument case _ => new Document(cu.getBuffer.getContents) } val lineDelimiter = TextUtilities.getDefaultLineDelimiter(document) val preferences = FormatterPreferences.getPreferences(cu.getJavaProject) val edits = try ScalaFormatter.formatAsEdits(cu.getSource, preferences, Some(lineDelimiter)) catch { case _: ScalaParserException => List() } val multiEdit = new MultiTextEdit multiEdit.addChildren(edits.map(asEclipseTextEdit).toArray) val change = new CompilationUnitChange("Formatting", cu) change.setEdit(multiEdit) new CodeFormatFix(change) } }
scala-ide/scala-ide
org.scala-ide.sdt.core/src/org/scalaide/core/internal/formatter/ScalaFormatterCleanUpProvider.scala
Scala
bsd-3-clause
1,534
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package kafka.cluster import java.nio.ByteBuffer import kafka.utils.Logging import org.apache.kafka.common.protocol.SecurityProtocol import org.junit.Test import scala.collection.mutable class BrokerEndPointTest extends Logging { @Test def testSerDe() = { val endpoint = new EndPoint("myhost", 9092, SecurityProtocol.PLAINTEXT) val listEndPoints = Map(SecurityProtocol.PLAINTEXT -> endpoint) val origBroker = new Broker(1, listEndPoints) val brokerBytes = ByteBuffer.allocate(origBroker.sizeInBytes) origBroker.writeTo(brokerBytes) val newBroker = Broker.readFrom(brokerBytes.flip().asInstanceOf[ByteBuffer]) assert(origBroker == newBroker) } @Test def testHashAndEquals() = { val endpoint1 = new EndPoint("myhost", 9092, SecurityProtocol.PLAINTEXT) val endpoint2 = new EndPoint("myhost", 9092, SecurityProtocol.PLAINTEXT) val endpoint3 = new EndPoint("myhost", 1111, SecurityProtocol.PLAINTEXT) val endpoint4 = new EndPoint("other", 1111, SecurityProtocol.PLAINTEXT) val broker1 = new Broker(1, Map(SecurityProtocol.PLAINTEXT -> endpoint1)) val broker2 = new Broker(1, Map(SecurityProtocol.PLAINTEXT -> endpoint2)) val broker3 = new Broker(2, Map(SecurityProtocol.PLAINTEXT -> endpoint3)) val broker4 = new Broker(1, Map(SecurityProtocol.PLAINTEXT -> endpoint4)) assert(broker1 == broker2) assert(broker1 != broker3) assert(broker1 != broker4) assert(broker1.hashCode() == broker2.hashCode()) assert(broker1.hashCode() != broker3.hashCode()) assert(broker1.hashCode() != broker4.hashCode()) val hashmap = new mutable.HashMap[Broker, Int]() hashmap.put(broker1, 1) assert(hashmap.getOrElse(broker1, -1) == 1) } @Test def testFromJSON() = { val brokerInfoStr = "{\\"version\\":2," + "\\"host\\":\\"localhost\\"," + "\\"port\\":9092," + "\\"jmx_port\\":9999," + "\\"timestamp\\":\\"1416974968782\\"," + "\\"endpoints\\":[\\"PLAINTEXT://localhost:9092\\"]}" val broker = Broker.createBroker(1, brokerInfoStr) assert(broker.id == 1) assert(broker.getBrokerEndPoint(SecurityProtocol.PLAINTEXT).host == "localhost") assert(broker.getBrokerEndPoint(SecurityProtocol.PLAINTEXT).port == 9092) } @Test def testFromOldJSON() = { val brokerInfoStr = "{\\"jmx_port\\":-1,\\"timestamp\\":\\"1420485325400\\",\\"host\\":\\"172.16.8.243\\",\\"version\\":1,\\"port\\":9091}" val broker = Broker.createBroker(1, brokerInfoStr) assert(broker.id == 1) assert(broker.getBrokerEndPoint(SecurityProtocol.PLAINTEXT).host == "172.16.8.243") assert(broker.getBrokerEndPoint(SecurityProtocol.PLAINTEXT).port == 9091) } @Test def testBrokerEndpointFromURI() = { var connectionString = "localhost:9092" var endpoint = BrokerEndPoint.createBrokerEndPoint(1, connectionString) assert(endpoint.host == "localhost") assert(endpoint.port == 9092) // also test for ipv6 connectionString = "[::1]:9092" endpoint = BrokerEndPoint.createBrokerEndPoint(1, connectionString) assert(endpoint.host == "::1") assert(endpoint.port == 9092) // add test for uppercase in hostname connectionString = "MyHostname:9092" endpoint = BrokerEndPoint.createBrokerEndPoint(1, connectionString) assert(endpoint.host == "MyHostname") assert(endpoint.port == 9092) } @Test def testEndpointFromURI() = { var connectionString = "PLAINTEXT://localhost:9092" var endpoint = EndPoint.createEndPoint(connectionString) assert(endpoint.host == "localhost") assert(endpoint.port == 9092) assert(endpoint.connectionString == "PLAINTEXT://localhost:9092") // also test for default bind connectionString = "PLAINTEXT://:9092" endpoint = EndPoint.createEndPoint(connectionString) assert(endpoint.host == null) assert(endpoint.port == 9092) assert(endpoint.connectionString == "PLAINTEXT://:9092") // also test for ipv6 connectionString = "PLAINTEXT://[::1]:9092" endpoint = EndPoint.createEndPoint(connectionString) assert(endpoint.host == "::1") assert(endpoint.port == 9092) assert(endpoint.connectionString == "PLAINTEXT://[::1]:9092") // test hostname connectionString = "PLAINTEXT://MyHostname:9092" endpoint = EndPoint.createEndPoint(connectionString) assert(endpoint.host == "MyHostname") assert(endpoint.port == 9092) assert(endpoint.connectionString == "PLAINTEXT://MyHostname:9092") } }
eljefe6a/kafka
core/src/test/scala/unit/kafka/cluster/BrokerEndPointTest.scala
Scala
apache-2.0
5,366
package com.thinkbiganalytics.spark.metadata import com.thinkbiganalytics.spark.SparkContextService import com.thinkbiganalytics.spark.dataprofiler.Profiler import com.thinkbiganalytics.spark.rest.model.TransformResponse import org.apache.spark.sql.{DataFrame, SQLContext} import org.slf4j.LoggerFactory /** Wraps a transform script into a function that can be evaluated. * * @param destination the name of the destination Hive table * @param sqlContext the Spark SQL context */ abstract class TransformScript20(destination: String, profiler: Profiler, sqlContext: SQLContext, sparkContextService: SparkContextService) extends TransformScript(destination, profiler) { private[this] val log = LoggerFactory.getLogger(classOf[TransformScript]) /** Evaluates this transform script and stores the result in a Hive table. */ def run(): QueryResultCallable = { new QueryResultCallable20 } /** Evaluates the transform script. * * @return the transformation result */ protected[metadata] def dataFrame: DataFrame /** Fetches or re-generates the results of the parent transformation, if available. * * @return the parent results */ protected def parent: DataFrame = { try { sqlContext.read.table(parentTable) } catch { case e: Exception => log.trace("Exception reading parent table: {}", e.toString) log.debug("Parent table not found: {}", parentTable) parentDataFrame } } /** Re-generates the parent transformation. * * @return the parent transformation */ protected override def parentDataFrame: DataFrame = { throw new UnsupportedOperationException } /** Stores the `DataFrame` results in a [[com.thinkbiganalytics.discovery.schema.QueryResult]] and returns the object. */ private class QueryResultCallable20 extends QueryResultCallable { override def call(): TransformResponse = { // Cache data frame val cache = dataFrame.cache cache.registerTempTable(destination) // Build response object toResponse(sparkContextService.toDataSet(cache)) } } }
rashidaligee/kylo
integrations/spark/spark-shell-client/spark-shell-client-v2/src/main/scala/com/thinkbiganalytics/spark/metadata/TransformScript20.scala
Scala
apache-2.0
2,270
/* * Copyright 2016 Dennis Vriend * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.github.dnvriend.streams.stage.simple import akka.stream.testkit.scaladsl.TestSink import com.github.dnvriend.streams.TestSpec class FilterStageTest extends TestSpec { /** * Only pass on those elements that satisfy the given predicate. * * - Emits when: the given predicate returns true for the element * - Backpressures when: the given predicate returns true for the element and downstream backpressures * - Completes when: upstream completes * - Cancels when: downstream cancels */ "Filter a sequence of numbers for even numbers" should "emit only even numbers" in { withIterator() { src ⇒ src.take(10) .filter(_ % 2 == 0) .runWith(TestSink.probe[Int]) .request(Integer.MAX_VALUE) .expectNext(0, 2, 4, 6, 8) .expectComplete() } } }
dnvriend/intro-to-akka-streams
src/test/scala/com/github/dnvriend/streams/stage/simple/FilterStageTest.scala
Scala
apache-2.0
1,429
package bazooka.server.service import com.google.inject._ import com.google.gwt.user.client.rpc._ import com.google.gwt.user.server.rpc._ @Singleton class BazookaRemoteServiceServlet extends RemoteServiceServlet { @Inject private var injector: Injector = _ override def processCall(payload: String) = { try { val request = RPC.decodeRequest(payload, null, this) val service = getServiceInstance(request.getMethod.getDeclaringClass); RPC.invokeAndEncodeResponse(service, request.getMethod, request.getParameters, request.getSerializationPolicy) } catch { case ex: IncompatibleRemoteServiceException => log("IncompatibleRemoteServiceException in the processCall(String) method", ex) RPC.encodeResponseForFailure(null, ex); } } private def getServiceInstance(serviceClass: Class[_]) = injector.getInstance(serviceClass) }
tiagofernandez/bazooka
src/main/scala/bazooka/server/servlet/BazookaRemoteServiceServlet.scala
Scala
mit
888
/* * Licensed to The Apereo Foundation under one or more contributor license * agreements. See the NOTICE file distributed with this work for additional * information regarding copyright ownership. * * The Apereo Foundation licenses this file to you under the Apache License, * Version 2.0, (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.tle.web.controls.universal.handlers.fileupload.details import com.tle.beans.item.attachments.Attachment import com.tle.common.Check import com.tle.common.filesystem.FileEntry import com.tle.core.services.ZipProgress import com.tle.web.controls.universal.handlers.fileupload.{AttachmentDelete, WebFileUploads} import com.tle.web.controls.universal.{ControlContext, DialogRenderOptions} import com.tle.web.sections.SectionInfo import com.tle.web.sections.events.RenderContext import com.tle.web.sections.render.{Label, SectionRenderable} import com.tle.web.sections.standard.TextField import com.tle.web.viewurl.ViewableResource trait ZipHandler { def zipProgress: Option[ZipProgress] def selectedAttachments: Map[String, Attachment] def unzip: ZipProgress def removeUnzipped(): Unit def unzipped: Boolean def unzippedEntries: Seq[FileEntry] } trait ViewerHandler { def viewableResource(info: SectionInfo): ViewableResource def viewerListModel: ViewersListModel } trait EditingHandler { def editingArea: String def syncEdits(filename: String): Unit } object DetailsPage { val LABEL_ERROR_BLANK = WebFileUploads.label("handlers.abstract.error.blank") } import com.tle.web.controls.universal.handlers.fileupload.details.DetailsPage._ trait DetailsPage { def editingAttachment: SectionInfo => Attachment def previewable: Boolean def renderDetails(context: RenderContext): (SectionRenderable, DialogRenderOptions => Unit) def prepareUI(info: SectionInfo): Unit def editAttachment(info: SectionInfo, a: Attachment, ctx: ControlContext): (Attachment, Option[AttachmentDelete]) def validate(info: SectionInfo): Boolean def displayName: TextField def validateDisplayName(info: SectionInfo): Option[(String, Label)] = { if (Check.isEmpty(displayName.getValue(info))) { Some("displayName" -> LABEL_ERROR_BLANK) } else None } }
equella/Equella
Source/Plugins/Core/com.equella.core/scalasrc/com/tle/web/controls/universal/handlers/fileupload/details/DetailsPage.scala
Scala
apache-2.0
2,750
package ore.models.project import scala.language.higherKinds import java.time.{Instant, OffsetDateTime, ZoneOffset} import java.util.Locale import ore.data.project.{Category, FlagReason, ProjectNamespace} import ore.db._ import ore.db.access._ import ore.db.impl.OrePostgresDriver.api._ import ore.db.impl.common._ import ore.db.impl.schema._ import ore.db.impl.{DefaultModelCompanion, OrePostgresDriver} import ore.member.{Joinable, MembershipDossier} import ore.models.admin.ProjectVisibilityChange import ore.models.api.ProjectApiKey import ore.models.project.Project.ProjectSettings import ore.models.statistic.ProjectView import ore.models.user.role.ProjectUserRole import ore.models.user.{User, UserOwned} import ore.permission.role.Role import ore.permission.scope.HasScope import ore.syntax._ import ore.util.StringLocaleFormatterUtils import cats.syntax.all._ import cats.{Functor, Monad, MonadError, Parallel} import io.circe.Json import io.circe.generic.JsonCodec import io.circe.syntax._ import slick.lifted import slick.lifted.{Rep, TableQuery} /** * Represents an Ore package. * * <p>Note: As a general rule, do not handle actions / results in model classes</p> * * @param pluginId Plugin ID * @param ownerName The owner Author for this project * @param ownerId User ID of Project owner * @param name Name of plugin * @param slug URL slug * @param recommendedVersionId The ID of this project's recommended version * @param topicId ID of forum topic * @param postId ID of forum topic post ID * @param isTopicDirty Whether this project's forum topic needs to be updated * @param visibility Whether this project is visible to the default user * @param notes JSON notes */ case class Project( pluginId: String, ownerName: String, ownerId: DbRef[User], name: String, slug: String, recommendedVersionId: Option[DbRef[Version]] = None, category: Category = Category.Undefined, description: Option[String], topicId: Option[Int] = None, postId: Option[Int] = None, visibility: Visibility = Visibility.Public, notes: Json = Json.obj(), settings: ProjectSettings = ProjectSettings() ) extends Named with Describable with Visitable { def namespace: ProjectNamespace = ProjectNamespace(ownerName, slug) /** * Returns the base URL for this Project. * * @return Base URL for project */ override def url: String = namespace.toString /** * Get all messages * @return */ def decodeNotes: Seq[Note] = notes.hcursor.getOrElse[Seq[Note]]("messages")(Nil).toTry.get //Should be safe. If it's not we got bigger problems def isOwner(user: Model[User]): Boolean = user.id.value == ownerId } /** * This modal is needed to convert the json */ @JsonCodec case class Note(message: String, user: DbRef[User], time: Long = System.currentTimeMillis()) { def printTime(implicit locale: Locale): String = StringLocaleFormatterUtils.prettifyDateAndTime(OffsetDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneOffset.UTC)) } object Project extends DefaultModelCompanion[Project, ProjectTable](TableQuery[ProjectTable]) { case class ProjectSettings( keywords: List[String] = Nil, homepage: Option[String] = None, issues: Option[String] = None, source: Option[String] = None, support: Option[String] = None, licenseName: Option[String] = None, licenseUrl: Option[String] = None, forumSync: Boolean = true ) implicit val query: ModelQuery[Project] = ModelQuery.from(this) implicit val assocWatchersQuery: AssociationQuery[ProjectWatchersTable, Project, User] = AssociationQuery.from[ProjectWatchersTable, Project, User](TableQuery[ProjectWatchersTable])(_.projectId, _.userId) implicit val hasScope: HasScope[Model[Project]] = HasScope.projectScope(_.id) private def queryRoleForTrust(projectId: Rep[DbRef[Project]], userId: Rep[DbRef[User]]) = { val q = for { m <- TableQuery[ProjectMembersTable] if m.projectId === projectId && m.userId === userId r <- TableQuery[ProjectRoleTable] if m.userId === r.userId && r.projectId === projectId } yield r.roleType q.to[Set] } lazy val roleForTrustQuery = lifted.Compiled(queryRoleForTrust _) implicit def projectHideable[F[_]]( implicit service: ModelService[F], F: Monad[F], parallel: Parallel[F] ): Hideable.Aux[F, Project, ProjectVisibilityChange, ProjectVisibilityChangeTable] = new Hideable[F, Project] { override type MVisibilityChange = ProjectVisibilityChange override type MVisibilityChangeTable = ProjectVisibilityChangeTable override def visibility(m: Project): Visibility = m.visibility /** * Sets whether this project is visible. * * @param visibility True if visible */ override def setVisibility(m: Model[Project])( visibility: Visibility, comment: String, creator: DbRef[User] ): F[(Model[Project], Model[ProjectVisibilityChange])] = { val updateOldChange = lastVisibilityChange(m)(ModelView.now(ProjectVisibilityChange)) .semiflatMap { vc => service.update(vc)( _.copy( resolvedAt = Some(OffsetDateTime.now()), resolvedBy = Some(creator) ) ) } .cata((), _ => ()) val createNewChange = service.insert( ProjectVisibilityChange( Some(creator), m.id, comment, None, None, visibility ) ) val updateProject = service.update(m)( _.copy( visibility = visibility ) ) updateOldChange *> (updateProject, createNewChange).parTupled } /** * Get VisibilityChanges */ override def visibilityChanges[V[_, _]: QueryView](m: Model[Project])( view: V[ProjectVisibilityChangeTable, Model[ProjectVisibilityChange]] ): V[ProjectVisibilityChangeTable, Model[ProjectVisibilityChange]] = view.filterView(_.projectId === m.id.value) } implicit val isUserOwned: UserOwned[Project] = (a: Project) => a.ownerId implicit def projectJoinable[F[_]]( implicit service: ModelService[F], F: MonadError[F, Throwable], par: Parallel[F] ): Joinable.Aux[F, Project, ProjectUserRole, ProjectRoleTable] = new Joinable[F, Project] { type RoleType = ProjectUserRole type RoleTypeTable = ProjectRoleTable override def transferOwner(m: Model[Project])(newOwner: DbRef[User]): F[Model[Project]] = { // Down-grade current owner to "Developer" val oldOwner = m.ownerId for { newOwnerUser <- ModelView .now(User) .get(newOwner) .getOrElseF(F.raiseError(new Exception("Could not find user to transfer owner to"))) t2 <- (this.memberships.getRoles(m)(oldOwner), this.memberships.getRoles(m)(newOwner)).parTupled (ownerRoles, userRoles) = t2 setOwner <- setOwner(m)(newOwnerUser) _ <- ownerRoles .filter(_.role == Role.ProjectOwner) .toVector .parTraverse(role => service.update(role)(_.copy(role = Role.ProjectDeveloper))) _ <- userRoles.toVector.parTraverse(role => service.update(role)(_.copy(role = Role.ProjectOwner))) } yield setOwner } private def setOwner(m: Model[Project])(user: Model[User]): F[Model[Project]] = { service.update(m)( _.copy( ownerId = user.id ) ) } override def memberships: MembershipDossier.Aux[F, Project, RoleType, RoleTypeTable] = MembershipDossier.projectHasMemberships override def userOwned: UserOwned[Project] = isUserOwned } implicit class ProjectModelOps(private val self: Model[Project]) extends AnyVal { /** * Returns ModelAccess to the user's who are watching this project. * * @return Users watching project */ def watchers[F[_]: ModelService: Functor] : ParentAssociationAccess[ProjectWatchersTable, Project, User, ProjectTable, UserTable, F] = new ModelAssociationAccessImpl(OrePostgresDriver)(Project, User).applyParent(self.id) /** * Returns [[ore.db.access.ChildAssociationAccess]] to [[User]]s who have starred this * project. * * @return Users who have starred this project */ def stars[F[_]: ModelService: Functor] : ChildAssociationAccess[ProjectStarsTable, User, Project, UserTable, ProjectTable, F] = new ModelAssociationAccessImpl[ProjectStarsTable, User, Project, UserTable, ProjectTable, F]( OrePostgresDriver )( User, Project ).applyChild(self.id) /** * Returns this Project's recommended version. * * @return Recommended version */ def recommendedVersion[QOptRet, SRet[_]]( view: ModelView[QOptRet, SRet, VersionTable, Model[Version]] ): Option[QOptRet] = self.recommendedVersionId.map(versions(view).get) /** * Sets the "starred" state of this Project for the specified User. * * @param user User to set starred state of */ def toggleStarredBy[F[_]]( user: Model[User] )(implicit service: ModelService[F], F: Monad[F]): F[Project] = for { contains <- self.stars.contains(user.id) _ <- if (contains) self.stars.removeAssoc(user.id) else self.stars.addAssoc(user.id) } yield self /** * Returns all flags on this project. * * @return Flags on project */ def flags[V[_, _]: QueryView](view: V[FlagTable, Model[Flag]]): V[FlagTable, Model[Flag]] = view.filterView(_.projectId === self.id.value) /** * Submits a flag on this project for the specified user. * * @param user Flagger * @param reason Reason for flagging */ def flagFor[F[_]](user: Model[User], reason: FlagReason, comment: String)( implicit service: ModelService[F] ): F[Model[Flag]] = { val userId = user.id.value require(userId != self.ownerId, "cannot flag own project") service.insert(Flag(self.id, user.id, reason, comment)) } /** * Returns the Channels in this Project. * * @return Channels in project */ def channels[V[_, _]: QueryView](view: V[ChannelTable, Model[Channel]]): V[ChannelTable, Model[Channel]] = view.filterView(_.projectId === self.id.value) /** * Returns all versions in this project. * * @return Versions in project */ def versions[V[_, _]: QueryView](view: V[VersionTable, Model[Version]]): V[VersionTable, Model[Version]] = view.filterView(_.projectId === self.id.value) /** * Returns the pages in this Project. * * @return Pages in project */ def pages[V[_, _]: QueryView](view: V[PageTable, Model[Page]]): V[PageTable, Model[Page]] = view.filterView(_.projectId === self.id.value) /** * Returns the parentless, root, pages for this project. * * @return Root pages of project */ def rootPages[V[_, _]: QueryView](view: V[PageTable, Model[Page]]): V[PageTable, Model[Page]] = view.sortView(_.name).filterView(p => p.projectId === self.id.value && p.parentId.isEmpty) def apiKeys[V[_, _]: QueryView]( view: V[ProjectApiKeyTable, Model[ProjectApiKey]] ): V[ProjectApiKeyTable, Model[ProjectApiKey]] = view.filterView(_.projectId === self.id.value) /** * Add new note */ def addNote[F[_]](message: Note)(implicit service: ModelService[F]): F[Model[Project]] = { val messages = self.decodeNotes :+ message service.update(self)( _.copy( notes = Json.obj( "messages" := messages ) ) ) } } }
SpongePowered/Ore
models/src/main/scala/ore/models/project/Project.scala
Scala
mit
12,017
package scala.pickling.json.list.t.`new` import org.scalatest.FunSuite import scala.pickling._, scala.pickling.Defaults._, json._ class JsonListTNewTest extends FunSuite { test("main") { val pickle = List(1, 2, 3).pickle assert(pickle.toString === """ |JSONPickle({ | "tpe": "scala.collection.immutable.$colon$colon[scala.Int]", | "head": 1, | "tl": { | "tpe": "scala.collection.immutable.$colon$colon[scala.Int]", | "head": 2, | "tl": { | "tpe": "scala.collection.immutable.$colon$colon[scala.Int]", | "head": 3, | "tl": { | "tpe": "scala.collection.immutable.Nil.type" | } | } | } |}) """.stripMargin.trim) assert(pickle.unpickle[List[Int]] === List(1, 2, 3)) } }
eed3si9n/pickling-historical
core/src/test/scala/pickling/run/json-list-t-new.scala
Scala
bsd-3-clause
821
/* * (c) Copyright 2014 LinkedIn Corp. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.linkedin.rookboom.web.dust.loader /** * @author Sergey Skrobotov, [email protected] */ trait TemplateLoader { def loadTemplates(): Map[String, String] def loadTemplates(since: Long): Map[String, String] }
linkedin/RookBoom
web/src/main/scala/com/linkedin/rookboom/web/dust/loader/TemplateLoader.scala
Scala
apache-2.0
857
package com.eclipsesource.schema import com.eclipsesource.schema.drafts.Version7 import com.eclipsesource.schema.test.JsonSpec import org.specs2.mutable.Specification class ConstSpec extends Specification with JsonSpec { "const draft7" in { import Version7._ implicit val validator = SchemaValidator(Some(Version7)) validate("const", "draft7") } }
eclipsesource/play-json-schema-validator
src/test/scala/com/eclipsesource/schema/ConstSpec.scala
Scala
apache-2.0
368
package revenueAnalysis import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.joda.time.DateTime import org.apache.spark.sql.functions._ import org.apache.spark.sql.{ UserDefinedFunction, DataFrame, SQLContext, GroupedData } import java.lang.Math import java.util.concurrent.TimeUnit object DataToParquet extends App { val sparkConf: SparkConf = Common.getSparkConf("DataToParquet") val sparkContext: SparkContext = new SparkContext(sparkConf) val sqlContext: SQLContext = new SQLContext(sparkContext) private val dataDir: String = "/Users/kellypet/Desktop/PredictionIO/Ecommerce-Price-Predict-Project/fb/" private val usersCSV: String = dataDir + "users.csv" private val viewsCSV: String = dataDir + "views.csv" private val itemsCSV: String = dataDir + "items.csv" private val purchasesCSV: String = dataDir + "conversions.csv" private val adsCSV: String = dataDir + "users_ads.csv" import sqlContext.implicits._ case class Users( userId: String, timestamp: String, signupTime: Double, registerCountry: String) extends Serializable val usersDF: DataFrame = sparkContext.textFile(usersCSV, 750) .map(line => { val fields: Array[String] = line.split(",") val numFields: Int = fields.size val userId: String = fields(0) val timestamp: String = fields(numFields - 1) val timeDate: DateTime = DateTime.parse(timestamp) val signupTime: Double = timeDate.getMillis.toDouble / 1000 val registerCountry: String = fields .slice(1, numFields - 1) .mkString(",") Users(userId, timestamp, signupTime, registerCountry) }) .toDF .dropDuplicates(Seq("userId")) usersDF.write.parquet("data/users.parquet") case class Conversions( userId: String, itemId: String, itemPrice: Double, quantity: Double, conversionTime: Double) extends Serializable val conversionDF: DataFrame = sparkContext.textFile(purchasesCSV, 750) .map(line => { val fields: Array[String] = line.split(",") val numFields: Int = fields.size val userId: String = fields(0) val itemId: String = fields(1) val itemPrice: Double = fields(2).trim.toDouble val quantity: Double = fields(3).trim.toInt val timestamp: String = fields(4) val timeDate: DateTime = DateTime.parse(timestamp) val conversionTime: Double = timeDate.getMillis.toDouble / 1000 Conversions(userId, itemId, itemPrice, quantity, conversionTime) }) .toDF .dropDuplicates(Seq("userId")) conversionDF.write.parquet("data/conversions.parquet") case class Views( userId: String, viewTime: Double) extends Serializable val viewsDF: DataFrame = sparkContext.textFile(viewsCSV, 750) .map(line => { val fields: Array[String] = line.split(",") val numFields: Int = fields.size val userId: String = fields(0) val timestamp: String = fields(2) val timeDate: DateTime = DateTime.parse(timestamp) val viewTime: Double = timeDate.getMillis.toDouble / 1000 Views(userId, viewTime) }) .toDF .dropDuplicates(Seq("userId")) viewsDF.write.parquet("data/views.parquet") case class UsersAds( userId: String, utmSource: String, utmCampaign: String, utmMedium: String, utmTerm: String, utmContent: String) val usersAds: DataFrame = sparkContext.textFile(adsCSV, 750) .map(line => { val fields = line.split(",") UsersAds( userId = fields(0), utmSource = fields(1), utmCampaign = fields(2), utmMedium = fields(3), utmTerm = fields(4), utmContent = fields(5)) }) .toDF .dropDuplicates(Seq("userId")) usersAds.write.parquet("data/ads.parquet") //var conversionDF = usersDF.join(usersConvDF, "userId") // var usersDF:DataFrame = sqlContext.read.parquet("data/users.parquet") // var userAndPurchaseDF = usersDF.join(conversionDF, "userId") // var viewsDF: DataFrame = sqlContext.read.parquet("data/views.parquet") // var activityDF = viewsDF.join(userAndPurchaseDF, "userId") // activityDF.write.parquet("data/userActivity.parquet") }
PredictionIO/open-academy
KellyPeterson/revenueAnalysis/src/main/scala/revenueAnalysis/dataToParquet.scala
Scala
apache-2.0
4,198
/* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package uk.gov.hmrc.ct.accounts.frs102.boxes import uk.gov.hmrc.ct.accounts.frs102.calculations.IntangibleAssetsCalculator import uk.gov.hmrc.ct.accounts.frs102.retriever.{AbridgedAccountsBoxRetriever, Frs102AccountsBoxRetriever, FullAccountsBoxRetriever} import uk.gov.hmrc.ct.box._ case class AC121(value: Option[Int]) extends CtBoxIdentifier(name = "Amortisation at [POA END]") with CtOptionalInteger with Input with ValidatableBox[Frs102AccountsBoxRetriever] with Validators { override def validate(boxRetriever: Frs102AccountsBoxRetriever): Set[CtValidation] = { collectErrors( validateMoney(value, min = 0) ) } } object AC121 extends Calculated[AC121, Frs102AccountsBoxRetriever] with IntangibleAssetsCalculator { override def calculate(boxRetriever: Frs102AccountsBoxRetriever): AC121 = { boxRetriever match { case x: AbridgedAccountsBoxRetriever => calculateAbridgedAC121(x.ac118(), x.ac119(), x.ac120(), x.ac211()) case x: FullAccountsBoxRetriever => calculateFullAC121(x.ac121A(), x.ac121B()) } } }
hmrc/ct-calculations
src/main/scala/uk/gov/hmrc/ct/accounts/frs102/boxes/AC121.scala
Scala
apache-2.0
1,673
/* * Copyright 2017 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package uk.gov.hmrc.apigateway.connector.impl import javax.inject.Singleton import uk.gov.hmrc.play.audit.http.config.LoadAuditingConfig import uk.gov.hmrc.play.audit.http.connector.AuditConnector import uk.gov.hmrc.play.config.RunMode @Singleton class MicroserviceAuditConnector extends AuditConnector with RunMode { override lazy val auditingConfig = LoadAuditingConfig(s"$env.auditing") }
hmrc/api-gateway
app/uk/gov/hmrc/apigateway/connector/impl/MicroserviceAuditConnector.scala
Scala
apache-2.0
1,002
package io.github.meln1k.vkApi.models.wall import play.api.libs.json.Json case class PostId(post_id: Long) object PostId { implicit val postIdReads = Json.reads[PostId] }
meln1k/vk-scala-api
src/main/scala/io/github/meln1k/vkApi/models/wall/PostId.scala
Scala
apache-2.0
177
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.intel.oap.expression import com.google.common.collect.Lists import com.intel.oap.ColumnarPluginConfig import org.apache.arrow.gandiva.evaluator._ import org.apache.arrow.gandiva.exceptions.GandivaException import org.apache.arrow.gandiva.expression._ import org.apache.arrow.vector.types.pojo.ArrowType import org.apache.arrow.vector.types.pojo.Field import org.apache.arrow.vector.types.DateUnit import org.apache.arrow.vector.types.pojo.ArrowType.ArrowTypeID import org.apache.spark.internal.Logging import org.apache.spark.sql.catalyst.expressions._ import org.apache.spark.sql.types._ import scala.collection.mutable.ListBuffer /** * A version of add that supports columnar processing for longs. */ class ColumnarAnd(left: Expression, right: Expression, original: Expression) extends And(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeAnd(Lists.newArrayList(left_node, right_node)) (funcNode, resultType) } } class ColumnarOr(left: Expression, right: Expression, original: Expression) extends Or(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeOr(Lists.newArrayList(left_node, right_node)) (funcNode, resultType) } } class ColumnarEndsWith(left: Expression, right: Expression, original: Expression) extends EndsWith(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction("ends_with", Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarStartsWith(left: Expression, right: Expression, original: Expression) extends StartsWith(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction("starts_with", Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarLike(left: Expression, right: Expression, original: Expression) extends Like(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction("like", Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarContains(left: Expression, right: Expression, original: Expression) extends Contains(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val (right_node, right_type): (TreeNode, ArrowType) = (TreeBuilder.makeStringLiteral(right.toString()), new ArrowType.Utf8()) val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction("is_substr", Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarEqualTo(left: Expression, right: Expression, original: Expression) extends EqualTo(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val unifiedType = CodeGeneration.getResultType(left_type, right_type) if (!left_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) left_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(left_node), unifiedType) } if (!right_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) right_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(right_node), unifiedType) } var function = "equal" val nanCheck = ColumnarPluginConfig.getConf.enableColumnarNaNCheck if (nanCheck) { unifiedType match { case t: ArrowType.FloatingPoint => function = "equal_with_nan" case _ => } } val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction(function, Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarEqualNull(left: Expression, right: Expression, original: Expression) extends EqualNullSafe(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val unifiedType = CodeGeneration.getResultType(left_type, right_type) if (!left_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) left_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(left_node), unifiedType) } if (!right_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) right_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(right_node), unifiedType) } var function = "equal" val nanCheck = ColumnarPluginConfig.getConf.enableColumnarNaNCheck if (nanCheck) { unifiedType match { case t: ArrowType.FloatingPoint => function = "equal_with_nan" case _ => } } val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction(function, Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarLessThan(left: Expression, right: Expression, original: Expression) extends LessThan(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val unifiedType = CodeGeneration.getResultType(left_type, right_type) if (!left_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) left_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(left_node), unifiedType) } if (!right_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) right_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(right_node), unifiedType) } var function = "less_than" val nanCheck = ColumnarPluginConfig.getConf.enableColumnarNaNCheck if (nanCheck) { unifiedType match { case t: ArrowType.FloatingPoint => function = "less_than_with_nan" case _ => } } val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction(function, Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarLessThanOrEqual(left: Expression, right: Expression, original: Expression) extends LessThanOrEqual(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val unifiedType = CodeGeneration.getResultType(left_type, right_type) if (!left_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) left_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(left_node), unifiedType) } if (!right_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) right_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(right_node), unifiedType) } var function = "less_than_or_equal_to" val nanCheck = ColumnarPluginConfig.getConf.enableColumnarNaNCheck if (nanCheck) { unifiedType match { case t: ArrowType.FloatingPoint => function = "less_than_or_equal_to_with_nan" case _ => } } val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction( function, Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarGreaterThan(left: Expression, right: Expression, original: Expression) extends GreaterThan(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val unifiedType = CodeGeneration.getResultType(left_type, right_type) if (!left_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) left_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(left_node), unifiedType) } if (!right_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) right_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(right_node), unifiedType) } var function = "greater_than" val nanCheck = ColumnarPluginConfig.getConf.enableColumnarNaNCheck if (nanCheck) { unifiedType match { case t: ArrowType.FloatingPoint => function = "greater_than_with_nan" case _ => } } val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction( function, Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarGreaterThanOrEqual(left: Expression, right: Expression, original: Expression) extends GreaterThanOrEqual(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) val unifiedType = CodeGeneration.getResultType(left_type, right_type) if (!left_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) left_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(left_node), unifiedType) } if (!right_type.equals(unifiedType)) { val func_name = CodeGeneration.getCastFuncName(unifiedType) right_node = TreeBuilder.makeFunction(func_name, Lists.newArrayList(right_node), unifiedType) } var function = "greater_than_or_equal_to" val nanCheck = ColumnarPluginConfig.getConf.enableColumnarNaNCheck if (nanCheck) { unifiedType match { case t: ArrowType.FloatingPoint => function = "greater_than_or_equal_to_with_nan" case _ => } } val resultType = new ArrowType.Bool() val funcNode = TreeBuilder.makeFunction( function, Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarShiftLeft(left: Expression, right: Expression, original: Expression) extends ShiftLeft(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) if (right_type.getTypeID != ArrowTypeID.Int) { throw new IllegalArgumentException("shiftleft requires for int type on second parameter") } val resultType = left_type val funcNode = TreeBuilder.makeFunction( "shift_left", Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } class ColumnarShiftRight(left: Expression, right: Expression, original: Expression) extends ShiftRight(left: Expression, right: Expression) with ColumnarExpression with Logging { override def doColumnarCodeGen(args: Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) var (right_node, right_type): (TreeNode, ArrowType) = right.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) if (right_type.getTypeID != ArrowTypeID.Int) { throw new IllegalArgumentException("shiftright requires for int type on second parameter") } val resultType = left_type val funcNode = TreeBuilder.makeFunction( "shift_right", Lists.newArrayList(left_node, right_node), resultType) (funcNode, resultType) } } object ColumnarBinaryOperator { def create(left: Expression, right: Expression, original: Expression): Expression = original match { case a: And => new ColumnarAnd(left, right, a) case o: Or => new ColumnarOr(left, right, o) case e: EqualTo => new ColumnarEqualTo(left, right, e) case e: EqualNullSafe => new ColumnarEqualNull(left, right, e) case l: LessThan => new ColumnarLessThan(left, right, l) case l: LessThanOrEqual => new ColumnarLessThanOrEqual(left, right, l) case g: GreaterThan => new ColumnarGreaterThan(left, right, g) case g: GreaterThanOrEqual => new ColumnarGreaterThanOrEqual(left, right, g) case e: EndsWith => new ColumnarEndsWith(left, right, e) case s: StartsWith => new ColumnarStartsWith(left, right, s) case c: Contains => new ColumnarContains(left, right, c) case l: Like => new ColumnarLike(left, right, l) case s: ShiftLeft => new ColumnarShiftLeft(left, right, s) case s: ShiftRight => new ColumnarShiftRight(left, right, s) case other => throw new UnsupportedOperationException(s"not currently supported: $other.") } }
Intel-bigdata/OAP
oap-native-sql/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryOperator.scala
Scala
apache-2.0
17,856
package domala import org.seasar.doma package object jdbc { // Alias of Doma type type SqlLogType = doma.jdbc.SqlLogType object SqlLogType { val RAW = doma.jdbc.SqlLogType.RAW val FORMATTED = doma.jdbc.SqlLogType.FORMATTED val NONE = doma.jdbc.SqlLogType.NONE } type Naming = doma.jdbc.Naming object Naming { val NONE: Naming = doma.jdbc.Naming.NONE val LOWER_CASE: Naming = doma.jdbc.Naming.LOWER_CASE val UPPER_CASE: Naming = doma.jdbc.Naming.UPPER_CASE val SNAKE_LOWER_CASE: Naming = doma.jdbc.Naming.SNAKE_LOWER_CASE val SNAKE_UPPER_CASE: Naming = doma.jdbc.Naming.SNAKE_UPPER_CASE val LENIENT_SNAKE_UPPER_CASE: Naming = doma.jdbc.Naming.LENIENT_SNAKE_UPPER_CASE } }
bakenezumi/domala
core/src/main/scala/domala/jdbc/package.scala
Scala
apache-2.0
724
package com.arcusys.valamis.model /** When to do randomization of child activities */ object ScopeType extends Enumeration { type ScopeType = Value val Instance = Value("instance") val Site = Value("site") val Page = Value("page") val Player = Value("player") }
ViLPy/Valamis
valamis-core/src/main/scala/com/arcusys/valamis/model/ScopeType.scala
Scala
lgpl-3.0
272
package skinny.validator import org.scalatest._ class ErrorsSpec extends FlatSpec with Matchers { behavior of "Errors" it should "be available" in { val instance = new Errors(Map()) instance should not be null } }
seratch/skinny-framework
validator/src/test/scala/skinny/validator/ErrorsSpec.scala
Scala
mit
233
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package kafka.server import java.io.{File, IOException} import java.util.concurrent.TimeUnit import java.util.concurrent.atomic.AtomicBoolean import com.yammer.metrics.core.Gauge import kafka.api._ import kafka.cluster.{BrokerEndPoint, Partition, Replica} import kafka.common._ import kafka.controller.KafkaController import kafka.log.{LogAppendInfo, LogManager} import kafka.message.{ByteBufferMessageSet, MessageSet} import kafka.metrics.KafkaMetricsGroup import kafka.utils._ import org.I0Itec.zkclient.ZkClient import org.apache.kafka.common.metrics.Metrics import org.apache.kafka.common.protocol.Errors import org.apache.kafka.common.utils.{Time => JTime} import scala.collection._ /* * Result metadata of a log append operation on the log */ case class LogAppendResult(info: LogAppendInfo, error: Option[Throwable] = None) { def errorCode = error match { case None => ErrorMapping.NoError case Some(e) => ErrorMapping.codeFor(e.getClass.asInstanceOf[Class[Throwable]]) } } /* * Result metadata of a log read operation on the log * @param info @FetchDataInfo returned by the @Log read * @param hw high watermark of the local replica * @param readSize amount of data that was read from the log i.e. size of the fetch * @param isReadFromLogEnd true if the request read up to the log end offset snapshot * when the read was initiated, false otherwise * @param error Exception if error encountered while reading from the log */ case class LogReadResult(info: FetchDataInfo, hw: Long, readSize: Int, isReadFromLogEnd : Boolean, error: Option[Throwable] = None) { def errorCode = error match { case None => ErrorMapping.NoError case Some(e) => ErrorMapping.codeFor(e.getClass.asInstanceOf[Class[Throwable]]) } override def toString = { "Fetch Data: [%s], HW: [%d], readSize: [%d], isReadFromLogEnd: [%b], error: [%s]" .format(info, hw, readSize, isReadFromLogEnd, error) } } object LogReadResult { val UnknownLogReadResult = LogReadResult(FetchDataInfo(LogOffsetMetadata.UnknownOffsetMetadata, MessageSet.Empty), -1L, -1, false) } case class BecomeLeaderOrFollowerResult(responseMap: collection.Map[(String, Int), Short], updatedLeaders: Set[Partition], updatedFollowers: Set[Partition], errorCode: Short) { override def toString = { "updated leaders: [%s], updated followers: [%s], update results: [%s], global error: [%d]" .format(updatedLeaders, updatedFollowers, responseMap, errorCode) } } object ReplicaManager { val HighWatermarkFilename = "replication-offset-checkpoint" } class ReplicaManager(val config: KafkaConfig, metrics: Metrics, time: Time, jTime: JTime, val zkUtils: ZkUtils, scheduler: Scheduler, val logManager: LogManager, val isShuttingDown: AtomicBoolean, threadNamePrefix: Option[String] = None) extends Logging with KafkaMetricsGroup { /* epoch of the controller that last changed the leader */ @volatile var controllerEpoch: Int = KafkaController.InitialControllerEpoch - 1 private val localBrokerId = config.brokerId private val allPartitions = new Pool[(String, Int), Partition] private val replicaStateChangeLock = new Object val replicaFetcherManager = new ReplicaFetcherManager(config, this, metrics, jTime, threadNamePrefix) private val highWatermarkCheckPointThreadStarted = new AtomicBoolean(false) val highWatermarkCheckpoints = config.logDirs.map(dir => (new File(dir).getAbsolutePath, new OffsetCheckpoint(new File(dir, ReplicaManager.HighWatermarkFilename)))).toMap private var hwThreadInitialized = false this.logIdent = "[Replica Manager on Broker " + localBrokerId + "]: " val stateChangeLogger = KafkaController.stateChangeLogger private val isrChangeSet: mutable.Set[TopicAndPartition] = new mutable.HashSet[TopicAndPartition]() val delayedProducePurgatory = new DelayedOperationPurgatory[DelayedProduce]( purgatoryName = "Produce", config.brokerId, config.producerPurgatoryPurgeIntervalRequests) val delayedFetchPurgatory = new DelayedOperationPurgatory[DelayedFetch]( purgatoryName = "Fetch", config.brokerId, config.fetchPurgatoryPurgeIntervalRequests) newGauge( "LeaderCount", new Gauge[Int] { def value = { getLeaderPartitions().size } } ) newGauge( "PartitionCount", new Gauge[Int] { def value = allPartitions.size } ) newGauge( "UnderReplicatedPartitions", new Gauge[Int] { def value = underReplicatedPartitionCount() } ) val isrExpandRate = newMeter("IsrExpandsPerSec", "expands", TimeUnit.SECONDS) val isrShrinkRate = newMeter("IsrShrinksPerSec", "shrinks", TimeUnit.SECONDS) def underReplicatedPartitionCount(): Int = { getLeaderPartitions().count(_.isUnderReplicated) } def startHighWaterMarksCheckPointThread() = { if(highWatermarkCheckPointThreadStarted.compareAndSet(false, true)) scheduler.schedule("highwatermark-checkpoint", checkpointHighWatermarks, period = config.replicaHighWatermarkCheckpointIntervalMs, unit = TimeUnit.MILLISECONDS) } def recordIsrChange(topicAndPartition: TopicAndPartition) { isrChangeSet synchronized { isrChangeSet += topicAndPartition } } def maybePropagateIsrChanges() { isrChangeSet synchronized { if (isrChangeSet.nonEmpty) { ReplicationUtils.propagateIsrChanges(zkUtils, isrChangeSet) isrChangeSet.clear() } } } /** * Try to complete some delayed produce requests with the request key; * this can be triggered when: * * 1. The partition HW has changed (for acks = -1) * 2. A follower replica's fetch operation is received (for acks > 1) */ def tryCompleteDelayedProduce(key: DelayedOperationKey) { val completed = delayedProducePurgatory.checkAndComplete(key) debug("Request key %s unblocked %d producer requests.".format(key.keyLabel, completed)) } /** * Try to complete some delayed fetch requests with the request key; * this can be triggered when: * * 1. The partition HW has changed (for regular fetch) * 2. A new message set is appended to the local log (for follower fetch) */ def tryCompleteDelayedFetch(key: DelayedOperationKey) { val completed = delayedFetchPurgatory.checkAndComplete(key) debug("Request key %s unblocked %d fetch requests.".format(key.keyLabel, completed)) } def startup() { // start ISR expiration thread scheduler.schedule("isr-expiration", maybeShrinkIsr, period = config.replicaLagTimeMaxMs, unit = TimeUnit.MILLISECONDS) scheduler.schedule("isr-change-propagation", maybePropagateIsrChanges, period = 5000, unit = TimeUnit.MILLISECONDS) } def stopReplica(topic: String, partitionId: Int, deletePartition: Boolean): Short = { stateChangeLogger.trace("Broker %d handling stop replica (delete=%s) for partition [%s,%d]".format(localBrokerId, deletePartition.toString, topic, partitionId)) val errorCode = ErrorMapping.NoError getPartition(topic, partitionId) match { case Some(partition) => if(deletePartition) { val removedPartition = allPartitions.remove((topic, partitionId)) if (removedPartition != null) removedPartition.delete() // this will delete the local log } case None => // Delete log and corresponding folders in case replica manager doesn't hold them anymore. // This could happen when topic is being deleted while broker is down and recovers. if(deletePartition) { val topicAndPartition = TopicAndPartition(topic, partitionId) if(logManager.getLog(topicAndPartition).isDefined) { logManager.deleteLog(topicAndPartition) } } stateChangeLogger.trace("Broker %d ignoring stop replica (delete=%s) for partition [%s,%d] as replica doesn't exist on broker" .format(localBrokerId, deletePartition, topic, partitionId)) } stateChangeLogger.trace("Broker %d finished handling stop replica (delete=%s) for partition [%s,%d]" .format(localBrokerId, deletePartition, topic, partitionId)) errorCode } def stopReplicas(stopReplicaRequest: StopReplicaRequest): (mutable.Map[TopicAndPartition, Short], Short) = { replicaStateChangeLock synchronized { val responseMap = new collection.mutable.HashMap[TopicAndPartition, Short] if(stopReplicaRequest.controllerEpoch < controllerEpoch) { stateChangeLogger.warn("Broker %d received stop replica request from an old controller epoch %d." .format(localBrokerId, stopReplicaRequest.controllerEpoch) + " Latest known controller epoch is %d " + controllerEpoch) (responseMap, ErrorMapping.StaleControllerEpochCode) } else { controllerEpoch = stopReplicaRequest.controllerEpoch // First stop fetchers for all partitions, then stop the corresponding replicas replicaFetcherManager.removeFetcherForPartitions(stopReplicaRequest.partitions.map(r => TopicAndPartition(r.topic, r.partition))) for(topicAndPartition <- stopReplicaRequest.partitions){ val errorCode = stopReplica(topicAndPartition.topic, topicAndPartition.partition, stopReplicaRequest.deletePartitions) responseMap.put(topicAndPartition, errorCode) } (responseMap, ErrorMapping.NoError) } } } def getOrCreatePartition(topic: String, partitionId: Int): Partition = { var partition = allPartitions.get((topic, partitionId)) if (partition == null) { allPartitions.putIfNotExists((topic, partitionId), new Partition(topic, partitionId, time, this)) partition = allPartitions.get((topic, partitionId)) } partition } def getPartition(topic: String, partitionId: Int): Option[Partition] = { val partition = allPartitions.get((topic, partitionId)) if (partition == null) None else Some(partition) } def getReplicaOrException(topic: String, partition: Int): Replica = { val replicaOpt = getReplica(topic, partition) if(replicaOpt.isDefined) replicaOpt.get else throw new ReplicaNotAvailableException("Replica %d is not available for partition [%s,%d]".format(config.brokerId, topic, partition)) } def getLeaderReplicaIfLocal(topic: String, partitionId: Int): Replica = { val partitionOpt = getPartition(topic, partitionId) partitionOpt match { case None => throw new UnknownTopicOrPartitionException("Partition [%s,%d] doesn't exist on %d".format(topic, partitionId, config.brokerId)) case Some(partition) => partition.leaderReplicaIfLocal match { case Some(leaderReplica) => leaderReplica case None => throw new NotLeaderForPartitionException("Leader not local for partition [%s,%d] on broker %d" .format(topic, partitionId, config.brokerId)) } } } def getReplica(topic: String, partitionId: Int, replicaId: Int = config.brokerId): Option[Replica] = { val partitionOpt = getPartition(topic, partitionId) partitionOpt match { case None => None case Some(partition) => partition.getReplica(replicaId) } } /** * Append messages to leader replicas of the partition, and wait for them to be replicated to other replicas; * the callback function will be triggered either when timeout or the required acks are satisfied */ def appendMessages(timeout: Long, requiredAcks: Short, internalTopicsAllowed: Boolean, messagesPerPartition: Map[TopicAndPartition, MessageSet], responseCallback: Map[TopicAndPartition, ProducerResponseStatus] => Unit) { if (isValidRequiredAcks(requiredAcks)) { val sTime = SystemTime.milliseconds val localProduceResults = appendToLocalLog(internalTopicsAllowed, messagesPerPartition, requiredAcks) debug("Produce to local log in %d ms".format(SystemTime.milliseconds - sTime)) val produceStatus = localProduceResults.map { case (topicAndPartition, result) => topicAndPartition -> ProducePartitionStatus( result.info.lastOffset + 1, // required offset ProducerResponseStatus(result.errorCode, result.info.firstOffset)) // response status } if (delayedRequestRequired(requiredAcks, messagesPerPartition, localProduceResults)) { // create delayed produce operation val produceMetadata = ProduceMetadata(requiredAcks, produceStatus) val delayedProduce = new DelayedProduce(timeout, produceMetadata, this, responseCallback) // create a list of (topic, partition) pairs to use as keys for this delayed produce operation val producerRequestKeys = messagesPerPartition.keys.map(new TopicPartitionOperationKey(_)).toSeq // try to complete the request immediately, otherwise put it into the purgatory // this is because while the delayed produce operation is being created, new // requests may arrive and hence make this operation completable. delayedProducePurgatory.tryCompleteElseWatch(delayedProduce, producerRequestKeys) } else { // we can respond immediately val produceResponseStatus = produceStatus.mapValues(status => status.responseStatus) responseCallback(produceResponseStatus) } } else { // If required.acks is outside accepted range, something is wrong with the client // Just return an error and don't handle the request at all val responseStatus = messagesPerPartition.map { case (topicAndPartition, messageSet) => (topicAndPartition -> ProducerResponseStatus(Errors.INVALID_REQUIRED_ACKS.code, LogAppendInfo.UnknownLogAppendInfo.firstOffset)) } responseCallback(responseStatus) } } // If all the following conditions are true, we need to put a delayed produce request and wait for replication to complete // // 1. required acks = -1 // 2. there is data to append // 3. at least one partition append was successful (fewer errors than partitions) private def delayedRequestRequired(requiredAcks: Short, messagesPerPartition: Map[TopicAndPartition, MessageSet], localProduceResults: Map[TopicAndPartition, LogAppendResult]): Boolean = { requiredAcks == -1 && messagesPerPartition.size > 0 && localProduceResults.values.count(_.error.isDefined) < messagesPerPartition.size } private def isValidRequiredAcks(requiredAcks: Short): Boolean = { requiredAcks == -1 || requiredAcks == 1 || requiredAcks == 0 } /** * Append the messages to the local replica logs */ private def appendToLocalLog(internalTopicsAllowed: Boolean, messagesPerPartition: Map[TopicAndPartition, MessageSet], requiredAcks: Short): Map[TopicAndPartition, LogAppendResult] = { trace("Append [%s] to local log ".format(messagesPerPartition)) messagesPerPartition.map { case (topicAndPartition, messages) => BrokerTopicStats.getBrokerTopicStats(topicAndPartition.topic).totalProduceRequestRate.mark() BrokerTopicStats.getBrokerAllTopicsStats().totalProduceRequestRate.mark() // reject appending to internal topics if it is not allowed if (Topic.InternalTopics.contains(topicAndPartition.topic) && !internalTopicsAllowed) { (topicAndPartition, LogAppendResult( LogAppendInfo.UnknownLogAppendInfo, Some(new InvalidTopicException("Cannot append to internal topic %s".format(topicAndPartition.topic))))) } else { try { val partitionOpt = getPartition(topicAndPartition.topic, topicAndPartition.partition) val info = partitionOpt match { case Some(partition) => partition.appendMessagesToLeader(messages.asInstanceOf[ByteBufferMessageSet], requiredAcks) case None => throw new UnknownTopicOrPartitionException("Partition %s doesn't exist on %d" .format(topicAndPartition, localBrokerId)) } val numAppendedMessages = if (info.firstOffset == -1L || info.lastOffset == -1L) 0 else info.lastOffset - info.firstOffset + 1 // update stats for successfully appended bytes and messages as bytesInRate and messageInRate BrokerTopicStats.getBrokerTopicStats(topicAndPartition.topic).bytesInRate.mark(messages.sizeInBytes) BrokerTopicStats.getBrokerAllTopicsStats.bytesInRate.mark(messages.sizeInBytes) BrokerTopicStats.getBrokerTopicStats(topicAndPartition.topic).messagesInRate.mark(numAppendedMessages) BrokerTopicStats.getBrokerAllTopicsStats.messagesInRate.mark(numAppendedMessages) trace("%d bytes written to log %s-%d beginning at offset %d and ending at offset %d" .format(messages.sizeInBytes, topicAndPartition.topic, topicAndPartition.partition, info.firstOffset, info.lastOffset)) (topicAndPartition, LogAppendResult(info)) } catch { // NOTE: Failed produce requests metric is not incremented for known exceptions // it is supposed to indicate un-expected failures of a broker in handling a produce request case e: KafkaStorageException => fatal("Halting due to unrecoverable I/O error while handling produce request: ", e) Runtime.getRuntime.halt(1) (topicAndPartition, null) case utpe: UnknownTopicOrPartitionException => (topicAndPartition, LogAppendResult(LogAppendInfo.UnknownLogAppendInfo, Some(utpe))) case nle: NotLeaderForPartitionException => (topicAndPartition, LogAppendResult(LogAppendInfo.UnknownLogAppendInfo, Some(nle))) case mtle: MessageSizeTooLargeException => (topicAndPartition, LogAppendResult(LogAppendInfo.UnknownLogAppendInfo, Some(mtle))) case mstle: MessageSetSizeTooLargeException => (topicAndPartition, LogAppendResult(LogAppendInfo.UnknownLogAppendInfo, Some(mstle))) case imse : InvalidMessageSizeException => (topicAndPartition, LogAppendResult(LogAppendInfo.UnknownLogAppendInfo, Some(imse))) case t: Throwable => BrokerTopicStats.getBrokerTopicStats(topicAndPartition.topic).failedProduceRequestRate.mark() BrokerTopicStats.getBrokerAllTopicsStats.failedProduceRequestRate.mark() error("Error processing append operation on partition %s".format(topicAndPartition), t) (topicAndPartition, LogAppendResult(LogAppendInfo.UnknownLogAppendInfo, Some(t))) } } } } /** * Fetch messages from the leader replica, and wait until enough data can be fetched and return; * the callback function will be triggered either when timeout or required fetch info is satisfied */ def fetchMessages(timeout: Long, replicaId: Int, fetchMinBytes: Int, fetchInfo: immutable.Map[TopicAndPartition, PartitionFetchInfo], responseCallback: Map[TopicAndPartition, FetchResponsePartitionData] => Unit) { val isFromFollower = replicaId >= 0 val fetchOnlyFromLeader: Boolean = replicaId != Request.DebuggingConsumerId val fetchOnlyCommitted: Boolean = ! Request.isValidBrokerId(replicaId) // read from local logs val logReadResults = readFromLocalLog(fetchOnlyFromLeader, fetchOnlyCommitted, fetchInfo) // if the fetch comes from the follower, // update its corresponding log end offset if(Request.isValidBrokerId(replicaId)) updateFollowerLogReadResults(replicaId, logReadResults) // check if this fetch request can be satisfied right away val bytesReadable = logReadResults.values.map(_.info.messageSet.sizeInBytes).sum val errorReadingData = logReadResults.values.foldLeft(false) ((errorIncurred, readResult) => errorIncurred || (readResult.errorCode != ErrorMapping.NoError)) // respond immediately if 1) fetch request does not want to wait // 2) fetch request does not require any data // 3) has enough data to respond // 4) some error happens while reading data if(timeout <= 0 || fetchInfo.size <= 0 || bytesReadable >= fetchMinBytes || errorReadingData) { val fetchPartitionData = logReadResults.mapValues(result => FetchResponsePartitionData(result.errorCode, result.hw, result.info.messageSet)) responseCallback(fetchPartitionData) } else { // construct the fetch results from the read results val fetchPartitionStatus = logReadResults.map { case (topicAndPartition, result) => (topicAndPartition, FetchPartitionStatus(result.info.fetchOffsetMetadata, fetchInfo.get(topicAndPartition).get)) } val fetchMetadata = FetchMetadata(fetchMinBytes, fetchOnlyFromLeader, fetchOnlyCommitted, isFromFollower, fetchPartitionStatus) val delayedFetch = new DelayedFetch(timeout, fetchMetadata, this, responseCallback) // create a list of (topic, partition) pairs to use as keys for this delayed fetch operation val delayedFetchKeys = fetchPartitionStatus.keys.map(new TopicPartitionOperationKey(_)).toSeq // try to complete the request immediately, otherwise put it into the purgatory; // this is because while the delayed fetch operation is being created, new requests // may arrive and hence make this operation completable. delayedFetchPurgatory.tryCompleteElseWatch(delayedFetch, delayedFetchKeys) } } /** * Read from a single topic/partition at the given offset upto maxSize bytes */ def readFromLocalLog(fetchOnlyFromLeader: Boolean, readOnlyCommitted: Boolean, readPartitionInfo: Map[TopicAndPartition, PartitionFetchInfo]): Map[TopicAndPartition, LogReadResult] = { readPartitionInfo.map { case (TopicAndPartition(topic, partition), PartitionFetchInfo(offset, fetchSize)) => BrokerTopicStats.getBrokerTopicStats(topic).totalFetchRequestRate.mark() BrokerTopicStats.getBrokerAllTopicsStats().totalFetchRequestRate.mark() val partitionDataAndOffsetInfo = try { trace("Fetching log segment for topic %s, partition %d, offset %d, size %d".format(topic, partition, offset, fetchSize)) // decide whether to only fetch from leader val localReplica = if (fetchOnlyFromLeader) getLeaderReplicaIfLocal(topic, partition) else getReplicaOrException(topic, partition) // decide whether to only fetch committed data (i.e. messages below high watermark) val maxOffsetOpt = if (readOnlyCommitted) Some(localReplica.highWatermark.messageOffset) else None /* Read the LogOffsetMetadata prior to performing the read from the log. * We use the LogOffsetMetadata to determine if a particular replica is in-sync or not. * Using the log end offset after performing the read can lead to a race condition * where data gets appended to the log immediately after the replica has consumed from it * This can cause a replica to always be out of sync. */ val initialLogEndOffset = localReplica.logEndOffset val logReadInfo = localReplica.log match { case Some(log) => log.read(offset, fetchSize, maxOffsetOpt) case None => error("Leader for partition [%s,%d] does not have a local log".format(topic, partition)) FetchDataInfo(LogOffsetMetadata.UnknownOffsetMetadata, MessageSet.Empty) } val readToEndOfLog = initialLogEndOffset.messageOffset - logReadInfo.fetchOffsetMetadata.messageOffset <= 0 LogReadResult(logReadInfo, localReplica.highWatermark.messageOffset, fetchSize, readToEndOfLog, None) } catch { // NOTE: Failed fetch requests metric is not incremented for known exceptions since it // is supposed to indicate un-expected failure of a broker in handling a fetch request case utpe: UnknownTopicOrPartitionException => LogReadResult(FetchDataInfo(LogOffsetMetadata.UnknownOffsetMetadata, MessageSet.Empty), -1L, fetchSize, false, Some(utpe)) case nle: NotLeaderForPartitionException => LogReadResult(FetchDataInfo(LogOffsetMetadata.UnknownOffsetMetadata, MessageSet.Empty), -1L, fetchSize, false, Some(nle)) case rnae: ReplicaNotAvailableException => LogReadResult(FetchDataInfo(LogOffsetMetadata.UnknownOffsetMetadata, MessageSet.Empty), -1L, fetchSize, false, Some(rnae)) case oor : OffsetOutOfRangeException => LogReadResult(FetchDataInfo(LogOffsetMetadata.UnknownOffsetMetadata, MessageSet.Empty), -1L, fetchSize, false, Some(oor)) case e: Throwable => BrokerTopicStats.getBrokerTopicStats(topic).failedFetchRequestRate.mark() BrokerTopicStats.getBrokerAllTopicsStats().failedFetchRequestRate.mark() error("Error processing fetch operation on partition [%s,%d] offset %d".format(topic, partition, offset)) LogReadResult(FetchDataInfo(LogOffsetMetadata.UnknownOffsetMetadata, MessageSet.Empty), -1L, fetchSize, false, Some(e)) } (TopicAndPartition(topic, partition), partitionDataAndOffsetInfo) } } def maybeUpdateMetadataCache(updateMetadataRequest: UpdateMetadataRequest, metadataCache: MetadataCache) { replicaStateChangeLock synchronized { if(updateMetadataRequest.controllerEpoch < controllerEpoch) { val stateControllerEpochErrorMessage = ("Broker %d received update metadata request with correlation id %d from an " + "old controller %d with epoch %d. Latest known controller epoch is %d").format(localBrokerId, updateMetadataRequest.correlationId, updateMetadataRequest.controllerId, updateMetadataRequest.controllerEpoch, controllerEpoch) stateChangeLogger.warn(stateControllerEpochErrorMessage) throw new ControllerMovedException(stateControllerEpochErrorMessage) } else { metadataCache.updateCache(updateMetadataRequest, localBrokerId, stateChangeLogger) controllerEpoch = updateMetadataRequest.controllerEpoch } } } def becomeLeaderOrFollower(leaderAndISRRequest: LeaderAndIsrRequest): BecomeLeaderOrFollowerResult = { leaderAndISRRequest.partitionStateInfos.foreach { case ((topic, partition), stateInfo) => stateChangeLogger.trace("Broker %d received LeaderAndIsr request %s correlation id %d from controller %d epoch %d for partition [%s,%d]" .format(localBrokerId, stateInfo, leaderAndISRRequest.correlationId, leaderAndISRRequest.controllerId, leaderAndISRRequest.controllerEpoch, topic, partition)) } replicaStateChangeLock synchronized { val responseMap = new mutable.HashMap[(String, Int), Short] if (leaderAndISRRequest.controllerEpoch < controllerEpoch) { leaderAndISRRequest.partitionStateInfos.foreach { case ((topic, partition), stateInfo) => stateChangeLogger.warn(("Broker %d ignoring LeaderAndIsr request from controller %d with correlation id %d since " + "its controller epoch %d is old. Latest known controller epoch is %d").format(localBrokerId, leaderAndISRRequest.controllerId, leaderAndISRRequest.correlationId, leaderAndISRRequest.controllerEpoch, controllerEpoch)) } BecomeLeaderOrFollowerResult(responseMap, Set.empty[Partition], Set.empty[Partition], ErrorMapping.StaleControllerEpochCode) } else { val controllerId = leaderAndISRRequest.controllerId val correlationId = leaderAndISRRequest.correlationId controllerEpoch = leaderAndISRRequest.controllerEpoch // First check partition's leader epoch val partitionState = new mutable.HashMap[Partition, PartitionStateInfo]() leaderAndISRRequest.partitionStateInfos.foreach { case ((topic, partitionId), partitionStateInfo) => val partition = getOrCreatePartition(topic, partitionId) val partitionLeaderEpoch = partition.getLeaderEpoch() // If the leader epoch is valid record the epoch of the controller that made the leadership decision. // This is useful while updating the isr to maintain the decision maker controller's epoch in the zookeeper path if (partitionLeaderEpoch < partitionStateInfo.leaderIsrAndControllerEpoch.leaderAndIsr.leaderEpoch) { if(partitionStateInfo.allReplicas.contains(config.brokerId)) partitionState.put(partition, partitionStateInfo) else { stateChangeLogger.warn(("Broker %d ignoring LeaderAndIsr request from controller %d with correlation id %d " + "epoch %d for partition [%s,%d] as itself is not in assigned replica list %s") .format(localBrokerId, controllerId, correlationId, leaderAndISRRequest.controllerEpoch, topic, partition.partitionId, partitionStateInfo.allReplicas.mkString(","))) } } else { // Otherwise record the error code in response stateChangeLogger.warn(("Broker %d ignoring LeaderAndIsr request from controller %d with correlation id %d " + "epoch %d for partition [%s,%d] since its associated leader epoch %d is old. Current leader epoch is %d") .format(localBrokerId, controllerId, correlationId, leaderAndISRRequest.controllerEpoch, topic, partition.partitionId, partitionStateInfo.leaderIsrAndControllerEpoch.leaderAndIsr.leaderEpoch, partitionLeaderEpoch)) responseMap.put((topic, partitionId), ErrorMapping.StaleLeaderEpochCode) } } val partitionsTobeLeader = partitionState.filter { case (partition, partitionStateInfo) => partitionStateInfo.leaderIsrAndControllerEpoch.leaderAndIsr.leader == config.brokerId } val partitionsToBeFollower = (partitionState -- partitionsTobeLeader.keys) val partitionsBecomeLeader = if (!partitionsTobeLeader.isEmpty) makeLeaders(controllerId, controllerEpoch, partitionsTobeLeader, leaderAndISRRequest.correlationId, responseMap) else Set.empty[Partition] val partitionsBecomeFollower = if (!partitionsToBeFollower.isEmpty) makeFollowers(controllerId, controllerEpoch, partitionsToBeFollower, leaderAndISRRequest.leaders, leaderAndISRRequest.correlationId, responseMap) else Set.empty[Partition] // we initialize highwatermark thread after the first leaderisrrequest. This ensures that all the partitions // have been completely populated before starting the checkpointing there by avoiding weird race conditions if (!hwThreadInitialized) { startHighWaterMarksCheckPointThread() hwThreadInitialized = true } replicaFetcherManager.shutdownIdleFetcherThreads() BecomeLeaderOrFollowerResult(responseMap, partitionsBecomeLeader, partitionsBecomeFollower, ErrorMapping.NoError) } } } /* * Make the current broker to become leader for a given set of partitions by: * * 1. Stop fetchers for these partitions * 2. Update the partition metadata in cache * 3. Add these partitions to the leader partitions set * * If an unexpected error is thrown in this function, it will be propagated to KafkaApis where * the error message will be set on each partition since we do not know which partition caused it * TODO: the above may need to be fixed later */ private def makeLeaders(controllerId: Int, epoch: Int, partitionState: Map[Partition, PartitionStateInfo], correlationId: Int, responseMap: mutable.Map[(String, Int), Short]): Set[Partition] = { partitionState.foreach(state => stateChangeLogger.trace(("Broker %d handling LeaderAndIsr request correlationId %d from controller %d epoch %d " + "starting the become-leader transition for partition %s") .format(localBrokerId, correlationId, controllerId, epoch, TopicAndPartition(state._1.topic, state._1.partitionId)))) for (partition <- partitionState.keys) responseMap.put((partition.topic, partition.partitionId), ErrorMapping.NoError) try { // First stop fetchers for all the partitions replicaFetcherManager.removeFetcherForPartitions(partitionState.keySet.map(new TopicAndPartition(_))) partitionState.foreach { state => stateChangeLogger.trace(("Broker %d stopped fetchers as part of become-leader request from controller " + "%d epoch %d with correlation id %d for partition %s") .format(localBrokerId, controllerId, epoch, correlationId, TopicAndPartition(state._1.topic, state._1.partitionId))) } // Update the partition information to be the leader partitionState.foreach{ case (partition, partitionStateInfo) => partition.makeLeader(controllerId, partitionStateInfo, correlationId)} } catch { case e: Throwable => partitionState.foreach { state => val errorMsg = ("Error on broker %d while processing LeaderAndIsr request correlationId %d received from controller %d" + " epoch %d for partition %s").format(localBrokerId, correlationId, controllerId, epoch, TopicAndPartition(state._1.topic, state._1.partitionId)) stateChangeLogger.error(errorMsg, e) } // Re-throw the exception for it to be caught in KafkaApis throw e } partitionState.foreach { state => stateChangeLogger.trace(("Broker %d completed LeaderAndIsr request correlationId %d from controller %d epoch %d " + "for the become-leader transition for partition %s") .format(localBrokerId, correlationId, controllerId, epoch, TopicAndPartition(state._1.topic, state._1.partitionId))) } partitionState.keySet } /* * Make the current broker to become follower for a given set of partitions by: * * 1. Remove these partitions from the leader partitions set. * 2. Mark the replicas as followers so that no more data can be added from the producer clients. * 3. Stop fetchers for these partitions so that no more data can be added by the replica fetcher threads. * 4. Truncate the log and checkpoint offsets for these partitions. * 5. If the broker is not shutting down, add the fetcher to the new leaders. * * The ordering of doing these steps make sure that the replicas in transition will not * take any more messages before checkpointing offsets so that all messages before the checkpoint * are guaranteed to be flushed to disks * * If an unexpected error is thrown in this function, it will be propagated to KafkaApis where * the error message will be set on each partition since we do not know which partition caused it */ private def makeFollowers(controllerId: Int, epoch: Int, partitionState: Map[Partition, PartitionStateInfo], leaders: Set[BrokerEndPoint], correlationId: Int, responseMap: mutable.Map[(String, Int), Short]) : Set[Partition] = { partitionState.foreach { state => stateChangeLogger.trace(("Broker %d handling LeaderAndIsr request correlationId %d from controller %d epoch %d " + "starting the become-follower transition for partition %s") .format(localBrokerId, correlationId, controllerId, epoch, TopicAndPartition(state._1.topic, state._1.partitionId))) } for (partition <- partitionState.keys) responseMap.put((partition.topic, partition.partitionId), ErrorMapping.NoError) val partitionsToMakeFollower: mutable.Set[Partition] = mutable.Set() try { // TODO: Delete leaders from LeaderAndIsrRequest partitionState.foreach{ case (partition, partitionStateInfo) => val leaderIsrAndControllerEpoch = partitionStateInfo.leaderIsrAndControllerEpoch val newLeaderBrokerId = leaderIsrAndControllerEpoch.leaderAndIsr.leader leaders.find(_.id == newLeaderBrokerId) match { // Only change partition state when the leader is available case Some(leaderBroker) => if (partition.makeFollower(controllerId, partitionStateInfo, correlationId)) partitionsToMakeFollower += partition else stateChangeLogger.info(("Broker %d skipped the become-follower state change after marking its partition as follower with correlation id %d from " + "controller %d epoch %d for partition [%s,%d] since the new leader %d is the same as the old leader") .format(localBrokerId, correlationId, controllerId, leaderIsrAndControllerEpoch.controllerEpoch, partition.topic, partition.partitionId, newLeaderBrokerId)) case None => // The leader broker should always be present in the leaderAndIsrRequest. // If not, we should record the error message and abort the transition process for this partition stateChangeLogger.error(("Broker %d received LeaderAndIsrRequest with correlation id %d from controller" + " %d epoch %d for partition [%s,%d] but cannot become follower since the new leader %d is unavailable.") .format(localBrokerId, correlationId, controllerId, leaderIsrAndControllerEpoch.controllerEpoch, partition.topic, partition.partitionId, newLeaderBrokerId)) // Create the local replica even if the leader is unavailable. This is required to ensure that we include // the partition's high watermark in the checkpoint file (see KAFKA-1647) partition.getOrCreateReplica() } } replicaFetcherManager.removeFetcherForPartitions(partitionsToMakeFollower.map(new TopicAndPartition(_))) partitionsToMakeFollower.foreach { partition => stateChangeLogger.trace(("Broker %d stopped fetchers as part of become-follower request from controller " + "%d epoch %d with correlation id %d for partition %s") .format(localBrokerId, controllerId, epoch, correlationId, TopicAndPartition(partition.topic, partition.partitionId))) } logManager.truncateTo(partitionsToMakeFollower.map(partition => (new TopicAndPartition(partition), partition.getOrCreateReplica().highWatermark.messageOffset)).toMap) partitionsToMakeFollower.foreach { partition => stateChangeLogger.trace(("Broker %d truncated logs and checkpointed recovery boundaries for partition [%s,%d] as part of " + "become-follower request with correlation id %d from controller %d epoch %d").format(localBrokerId, partition.topic, partition.partitionId, correlationId, controllerId, epoch)) } if (isShuttingDown.get()) { partitionsToMakeFollower.foreach { partition => stateChangeLogger.trace(("Broker %d skipped the adding-fetcher step of the become-follower state change with correlation id %d from " + "controller %d epoch %d for partition [%s,%d] since it is shutting down").format(localBrokerId, correlationId, controllerId, epoch, partition.topic, partition.partitionId)) } } else { // we do not need to check if the leader exists again since this has been done at the beginning of this process val partitionsToMakeFollowerWithLeaderAndOffset = partitionsToMakeFollower.map(partition => new TopicAndPartition(partition) -> BrokerAndInitialOffset( leaders.find(_.id == partition.leaderReplicaIdOpt.get).get, partition.getReplica().get.logEndOffset.messageOffset)).toMap replicaFetcherManager.addFetcherForPartitions(partitionsToMakeFollowerWithLeaderAndOffset) partitionsToMakeFollower.foreach { partition => stateChangeLogger.trace(("Broker %d started fetcher to new leader as part of become-follower request from controller " + "%d epoch %d with correlation id %d for partition [%s,%d]") .format(localBrokerId, controllerId, epoch, correlationId, partition.topic, partition.partitionId)) } } } catch { case e: Throwable => val errorMsg = ("Error on broker %d while processing LeaderAndIsr request with correlationId %d received from controller %d " + "epoch %d").format(localBrokerId, correlationId, controllerId, epoch) stateChangeLogger.error(errorMsg, e) // Re-throw the exception for it to be caught in KafkaApis throw e } partitionState.foreach { state => stateChangeLogger.trace(("Broker %d completed LeaderAndIsr request correlationId %d from controller %d epoch %d " + "for the become-follower transition for partition %s") .format(localBrokerId, correlationId, controllerId, epoch, TopicAndPartition(state._1.topic, state._1.partitionId))) } partitionsToMakeFollower } private def maybeShrinkIsr(): Unit = { trace("Evaluating ISR list of partitions to see which replicas can be removed from the ISR") allPartitions.values.foreach(partition => partition.maybeShrinkIsr(config.replicaLagTimeMaxMs)) } private def updateFollowerLogReadResults(replicaId: Int, readResults: Map[TopicAndPartition, LogReadResult]) { debug("Recording follower broker %d log read results: %s ".format(replicaId, readResults)) readResults.foreach { case (topicAndPartition, readResult) => getPartition(topicAndPartition.topic, topicAndPartition.partition) match { case Some(partition) => partition.updateReplicaLogReadResult(replicaId, readResult) // for producer requests with ack > 1, we need to check // if they can be unblocked after some follower's log end offsets have moved tryCompleteDelayedProduce(new TopicPartitionOperationKey(topicAndPartition)) case None => warn("While recording the replica LEO, the partition %s hasn't been created.".format(topicAndPartition)) } } } private def getLeaderPartitions() : List[Partition] = { allPartitions.values.filter(_.leaderReplicaIfLocal().isDefined).toList } // Flushes the highwatermark value for all partitions to the highwatermark file def checkpointHighWatermarks() { val replicas = allPartitions.values.map(_.getReplica(config.brokerId)).collect{case Some(replica) => replica} val replicasByDir = replicas.filter(_.log.isDefined).groupBy(_.log.get.dir.getParentFile.getAbsolutePath) for((dir, reps) <- replicasByDir) { val hwms = reps.map(r => (new TopicAndPartition(r) -> r.highWatermark.messageOffset)).toMap try { highWatermarkCheckpoints(dir).write(hwms) } catch { case e: IOException => fatal("Error writing to highwatermark file: ", e) Runtime.getRuntime().halt(1) } } } // High watermark do not need to be checkpointed only when under unit tests def shutdown(checkpointHW: Boolean = true) { info("Shutting down") replicaFetcherManager.shutdown() delayedFetchPurgatory.shutdown() delayedProducePurgatory.shutdown() if (checkpointHW) checkpointHighWatermarks() info("Shut down completely") } }
vkroz/kafka
core/src/main/scala/kafka/server/ReplicaManager.scala
Scala
apache-2.0
45,229
/** * Copyright (C) 2019 Orbeon, Inc. * * This program is free software; you can redistribute it and/or modify it under the terms of the * GNU Lesser General Public License as published by the Free Software Foundation; either version * 2.1 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU Lesser General Public License for more details. * * The full text of the license is available at http://www.gnu.org/copyleft/lesser.html */ package org.orbeon.oxf.fr.persistence.test import org.orbeon.oxf.fr.persistence.db.Connect import org.orbeon.oxf.fr.persistence.http.HttpCall import org.orbeon.oxf.fr.persistence.relational.Version.Specific import org.orbeon.oxf.http.HttpMethod.POST import org.orbeon.oxf.test.{DocumentTestBase, ResourceManagerSupport, XFormsSupport} import org.orbeon.oxf.util.{CoreCrossPlatformSupport, IndentedLogger, LoggerFactory} import org.orbeon.oxf.xml.dom.Converter._ import org.scalatest.funspec.AnyFunSpecLike class SearchTest extends DocumentTestBase with XFormsSupport with ResourceManagerSupport with AnyFunSpecLike { private implicit val Logger = new IndentedLogger(LoggerFactory.createLogger(classOf[SearchTest]), true) private implicit val coreCrossPlatformSupport = CoreCrossPlatformSupport describe("Search API") { it("returns an empty result when there are no documents") { withTestExternalContext { implicit externalContext => Connect.withOrbeonTables("form definition") { (connection, provider) => val FormURL = HttpCall.crudURLPrefix (provider) + "form/form.xhtml" val DataURL = HttpCall.crudURLPrefix (provider) + "data/123/data.xml" val SearchURL = HttpCall.searchURLPrefix(provider) val data = <form> <my-section> <my-field>42</my-field> </my-section> </form>.toDocument val searchRequest = <search> <query/> <drafts>include</drafts> <page-size>10</page-size> <page-number>1</page-number> <lang>en</lang> </search>.toDocument val searchResult = <documents search-total="0"/>.toDocument HttpCall.assertCall( HttpCall.SolicitedRequest( path = SearchURL, version = Specific(1), method = POST, body = Some(HttpCall.XML(searchRequest)) ), HttpCall.ExpectedResponse( code = 200, body = Some(HttpCall.XML(searchResult)) ) ) } } } } }
orbeon/orbeon-forms
form-runner/jvm/src/db/scala/org/orbeon/oxf/fr/persistence/test/SearchTest.scala
Scala
lgpl-2.1
2,860
package org.genericConfig.admin.models.config import org.genericConfig.admin.controllers.websocket.WebClient import org.genericConfig.admin.models.CommonFunction import org.genericConfig.admin.models.common.ConfigIdHashNotExist import org.genericConfig.admin.shared.Actions import org.genericConfig.admin.shared.config.{ConfigDTO, ConfigParamsDTO} import org.specs2.mutable.Specification import org.specs2.specification.BeforeAfterAll import play.api.Logger import play.api.libs.json.{JsResult, Json} /** * Copyright (C) 2016 Gennadi Heimann [email protected] * * Created by Gennadi Heimann 02.05.2018 */ //@RunWith(classOf[JUnitRunner]) class DeleteConfigWithDefectIdSpecs extends Specification with BeforeAfterAll with CommonFunction{ val wC: WebClient = WebClient.init val username = "user_v016_5" var deleteConfigResult : JsResult[ConfigDTO] = _ def beforeAll(): Unit = { before() } def afterAll(): Unit = { // Logger.info("Deleting Configs : " + deleteAllConfigs(this.username)) } "Der Binutzer versucht die Konfiguration mit defkten Id zu loeschen" >> { "action = DELETE_CONFIG" >> { deleteConfigResult.get.action === Actions.DELETE_CONFIG } "result.errors = ConfigIdHashNotExist" >> { deleteConfigResult.get.result.get.errors.get.head.name === ConfigIdHashNotExist().name } } private def before(): Unit = { val userId : String = createUser(username, wC) Logger.info(userId) val configId : String = createConfig(userId,"//http://contig1/user_v016_5") val deleteConfigParams = Json.toJson( ConfigDTO( action = Actions.DELETE_CONFIG, params = Some(ConfigParamsDTO( userId = None, configId = Some("1111"), configUrl = None, configurationCourse = None, update = None )), result = None ) ) Logger.info("<- " + deleteConfigParams) deleteConfigResult = Json.fromJson[ConfigDTO](wC.handleMessage(deleteConfigParams)) Logger.info("-> " + deleteConfigResult) } }
gennadij/admin
server/test/org/genericConfig/admin/models/config/DeleteConfigWithDefectIdSpecs.scala
Scala
apache-2.0
2,123
/** Copyright (C) 2012 Edge System Design, LLC. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * * Author(s): Ricky Elrod <[email protected]> */ package com.edgesysdesign.simpleradio.tests import com.edgesysdesign.simpleradio._ import junit.framework.Assert._ import _root_.android.test.AndroidTestCase import _root_.android.test.ActivityInstrumentationTestCase2 class AndroidTests extends AndroidTestCase { def testPackageIsCorrect() { assertEquals("com.edgesysdesign.simpleradio", getContext.getPackageName) } } class ActivityTests extends ActivityInstrumentationTestCase2(classOf[MainActivity]) { def testHelloWorldIsShown() { val activity = getActivity val textview = activity.findView(TR.textview) assertEquals(textview.getText, "hello, world!") } }
edge-sys-design/simple-radio
tests/src/main/scala/Tests.scala
Scala
gpl-2.0
1,441
package ca.uqam.euler.nicolas /** * Starting with the number 1 and moving to the right * in a clockwise direction a 5 by 5 spiral is formed * as follows: * * 21 22 23 24 25 * 20 7 8 9 10 * 19 6 1 2 11 * 18 5 4 3 12 * 17 16 15 14 13 * * It can be verified that the sum of the numbers on the * diagonals is 101. What is the sum of the numbers on * the diagonals in a 1001 by 1001 spiral formed in the * same way? * */ object Problem028 { case class V(x: Int, y: Int) { def +(v: V) = V(x + v.x, y + v.y) } type M = IndexedSeq[IndexedSeq[Int]] def dirs = { def f(unused: Seq[V], used: Seq[V]): Stream[V] = if (unused.nonEmpty) unused.head #:: f(unused.tail, unused.head +: used) else f(used.reverse, Nil) f(Seq(V(-1, 0), V(0, 1), V(1, 0), V(0, -1)), Nil) } def makeSpiral(size: Int) = { assert(size % 2 == 1) def look(m: M, p: V) = if (m.isDefinedAt(p.x)) if (m(p.x).isDefinedAt(p.y)) Some(m(p.x)(p.y)) else None else None def updated(m: M, pos: V, i: Int) = m.updated(pos.x, m(pos.x).updated(pos.y, i)) def f(i: Int, p: V, dirs: Stream[V], m: M): M = { val q = p + dirs.tail.head if (look(m, q) == Some(0)) f(i + 1, q, dirs.tail, updated(m, p, i)) else if (look(m, p) == None) m else f(i + 1, p + dirs.head, dirs, updated(m, p, i)) } f(1, V(size / 2, size / 2), dirs, IndexedSeq.tabulate(size, size)((x, y) => 0)) } def diagSum(m: M) = (0 until m.size).map { x => m(x)(x) + m(x)(m.size - x - 1) }.sum - 1 def main(args: Array[String]) = Answer { diagSum(makeSpiral(1001)) } }
nicolaspayette/project-euler
src/main/scala/ca/uqam/euler/nicolas/Problem028.scala
Scala
mit
1,702
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package kafka.utils import kafka.cluster.{Broker, Cluster} import kafka.consumer.TopicCount import org.I0Itec.zkclient.{IZkDataListener, ZkClient} import org.I0Itec.zkclient.exception.{ZkNodeExistsException, ZkNoNodeException, ZkMarshallingError} import org.I0Itec.zkclient.serialize.ZkSerializer import scala.collection._ import kafka.api.LeaderAndIsr import mutable.HashMap import org.apache.zookeeper.data.Stat import java.util.concurrent.locks.{ReentrantLock, Condition} import kafka.admin._ import kafka.common.{TopicAndPartition, KafkaException, NoEpochForPartitionException} import kafka.controller.{LeaderIsrAndControllerEpoch, PartitionAndReplica, ReassignedPartitionsContext} object ZkUtils extends Logging { val ConsumersPath = "/consumers" val BrokerIdsPath = "/brokers/ids" val BrokerTopicsPath = "/brokers/topics" val ControllerPath = "/controller" val ControllerEpochPath = "/controllerEpoch" val ReassignPartitionsPath = "/admin/reassign_partitions" val PreferredReplicaLeaderElectionPath = "/admin/preferred_replica_election" def getTopicPath(topic: String): String ={ BrokerTopicsPath + "/" + topic } def getTopicPartitionsPath(topic: String): String ={ getTopicPath(topic) + "/partitions" } def getController(zkClient: ZkClient): Int= { readDataMaybeNull(zkClient, ControllerPath)._1 match { case Some(controller) => controller.toInt case None => throw new KafkaException("Controller doesn't exist") } } def getTopicPartitionPath(topic: String, partitionId: Int): String ={ getTopicPartitionsPath(topic) + "/" + partitionId } def getTopicPartitionLeaderAndIsrPath(topic: String, partitionId: Int): String ={ getTopicPartitionPath(topic, partitionId) + "/" + "leaderAndISR" } def getSortedBrokerList(zkClient: ZkClient): Seq[String] ={ ZkUtils.getChildren(zkClient, ZkUtils.BrokerIdsPath).sorted } def getAllLiveBrokerIds(zkClient: ZkClient): Set[Int] = { ZkUtils.getChildren(zkClient, BrokerIdsPath).map(_.toInt).toSet } def getAllBrokersInCluster(zkClient: ZkClient): Seq[Broker] = { val brokerIds = ZkUtils.getChildren(zkClient, ZkUtils.BrokerIdsPath).sorted brokerIds.map(_.toInt).map(getBrokerInfo(zkClient, _)).filter(_.isDefined).map(_.get) } def getLeaderIsrAndEpochForPartition(zkClient: ZkClient, topic: String, partition: Int):Option[LeaderIsrAndControllerEpoch] = { val leaderAndIsrPath = getTopicPartitionLeaderAndIsrPath(topic, partition) val leaderAndIsrInfo = readDataMaybeNull(zkClient, leaderAndIsrPath) val leaderAndIsrOpt = leaderAndIsrInfo._1 val stat = leaderAndIsrInfo._2 leaderAndIsrOpt match { case Some(leaderAndIsrStr) => parseLeaderAndIsr(leaderAndIsrStr, topic, partition, stat) case None => None } } def getLeaderAndIsrForPartition(zkClient: ZkClient, topic: String, partition: Int):Option[LeaderAndIsr] = { getLeaderIsrAndEpochForPartition(zkClient, topic, partition).map(_.leaderAndIsr) } def parseLeaderAndIsr(leaderAndIsrStr: String, topic: String, partition: Int, stat: Stat) : Option[LeaderIsrAndControllerEpoch] = { Json.parseFull(leaderAndIsrStr) match { case Some(m) => val leader = m.asInstanceOf[Map[String, String]].get("leader").get.toInt val epoch = m.asInstanceOf[Map[String, String]].get("leaderEpoch").get.toInt val isrString = m.asInstanceOf[Map[String, String]].get("ISR").get val controllerEpoch = m.asInstanceOf[Map[String, String]].get("controllerEpoch").get.toInt val isr = Utils.parseCsvList(isrString).map(r => r.toInt) val zkPathVersion = stat.getVersion debug("Leader %d, Epoch %d, Isr %s, Zk path version %d for topic %s and partition %d".format(leader, epoch, isr.toString(), zkPathVersion, topic, partition)) Some(LeaderIsrAndControllerEpoch(LeaderAndIsr(leader, epoch, isr.toList, zkPathVersion), controllerEpoch)) case None => None } } def getLeaderForPartition(zkClient: ZkClient, topic: String, partition: Int): Option[Int] = { val leaderAndIsrOpt = readDataMaybeNull(zkClient, getTopicPartitionLeaderAndIsrPath(topic, partition))._1 leaderAndIsrOpt match { case Some(leaderAndIsr) => Json.parseFull(leaderAndIsr) match { case Some(m) => Some(m.asInstanceOf[Map[String, String]].get("leader").get.toInt) case None => None } case None => None } } /** * This API should read the epoch in the ISR path. It is sufficient to read the epoch in the ISR path, since if the * leader fails after updating epoch in the leader path and before updating epoch in the ISR path, effectively some * other broker will retry becoming leader with the same new epoch value. */ def getEpochForPartition(zkClient: ZkClient, topic: String, partition: Int): Int = { val leaderAndIsrOpt = readDataMaybeNull(zkClient, getTopicPartitionLeaderAndIsrPath(topic, partition))._1 leaderAndIsrOpt match { case Some(leaderAndIsr) => Json.parseFull(leaderAndIsr) match { case None => throw new NoEpochForPartitionException("No epoch, leaderAndISR data for topic %s partition %d is invalid".format(topic, partition)) case Some(m) => m.asInstanceOf[Map[String, String]].get("leaderEpoch").get.toInt } case None => throw new NoEpochForPartitionException("No epoch, ISR path for topic %s partition %d is empty" .format(topic, partition)) } } /** * Gets the in-sync replicas (ISR) for a specific topic and partition */ def getInSyncReplicasForPartition(zkClient: ZkClient, topic: String, partition: Int): Seq[Int] = { val leaderAndIsrOpt = readDataMaybeNull(zkClient, getTopicPartitionLeaderAndIsrPath(topic, partition))._1 leaderAndIsrOpt match { case Some(leaderAndIsr) => Json.parseFull(leaderAndIsr) match { case Some(m) => val isrString = m.asInstanceOf[Map[String, String]].get("ISR").get Utils.parseCsvList(isrString).map(r => r.toInt) case None => Seq.empty[Int] } case None => Seq.empty[Int] } } /** * Gets the assigned replicas (AR) for a specific topic and partition */ def getReplicasForPartition(zkClient: ZkClient, topic: String, partition: Int): Seq[Int] = { val jsonPartitionMapOpt = readDataMaybeNull(zkClient, getTopicPath(topic))._1 jsonPartitionMapOpt match { case Some(jsonPartitionMap) => Json.parseFull(jsonPartitionMap) match { case Some(m) => m.asInstanceOf[Map[String, List[String]]].get(partition.toString) match { case None => Seq.empty[Int] case Some(seq) => seq.map(_.toInt) } case None => Seq.empty[Int] } case None => Seq.empty[Int] } } def isPartitionOnBroker(zkClient: ZkClient, topic: String, partition: Int, brokerId: Int): Boolean = { val replicas = getReplicasForPartition(zkClient, topic, partition) debug("The list of replicas for topic %s, partition %d is %s".format(topic, partition, replicas)) replicas.contains(brokerId.toString) } def registerBrokerInZk(zkClient: ZkClient, id: Int, host: String, port: Int) { val brokerIdPath = ZkUtils.BrokerIdsPath + "/" + id val broker = new Broker(id, host, port) try { createEphemeralPathExpectConflict(zkClient, brokerIdPath, broker.getZkString) } catch { case e: ZkNodeExistsException => throw new RuntimeException("A broker is already registered on the path " + brokerIdPath + ". This probably " + "indicates that you either have configured a brokerid that is already in use, or " + "else you have shutdown this broker and restarted it faster than the zookeeper " + "timeout so it appears to be re-registering.") } info("Registering broker " + brokerIdPath + " succeeded with " + broker) } def getConsumerPartitionOwnerPath(group: String, topic: String, partition: Int): String = { val topicDirs = new ZKGroupTopicDirs(group, topic) topicDirs.consumerOwnerDir + "/" + partition } def leaderAndIsrZkData(leaderAndIsr: LeaderAndIsr, controllerEpoch: Int): String = { val jsonDataMap = new HashMap[String, String] jsonDataMap.put("leader", leaderAndIsr.leader.toString) jsonDataMap.put("leaderEpoch", leaderAndIsr.leaderEpoch.toString) jsonDataMap.put("ISR", leaderAndIsr.isr.mkString(",")) jsonDataMap.put("controllerEpoch", controllerEpoch.toString) Utils.stringMapToJson(jsonDataMap) } /** * make sure a persistent path exists in ZK. Create the path if not exist. */ def makeSurePersistentPathExists(client: ZkClient, path: String) { if (!client.exists(path)) client.createPersistent(path, true) // won't throw NoNodeException or NodeExistsException } /** * create the parent path */ private def createParentPath(client: ZkClient, path: String): Unit = { val parentDir = path.substring(0, path.lastIndexOf('/')) if (parentDir.length != 0) client.createPersistent(parentDir, true) } /** * Create an ephemeral node with the given path and data. Create parents if necessary. */ private def createEphemeralPath(client: ZkClient, path: String, data: String): Unit = { try { client.createEphemeral(path, data) } catch { case e: ZkNoNodeException => { createParentPath(client, path) client.createEphemeral(path, data) } } } /** * Create an ephemeral node with the given path and data. * Throw NodeExistException if node already exists. */ def createEphemeralPathExpectConflict(client: ZkClient, path: String, data: String): Unit = { try { createEphemeralPath(client, path, data) } catch { case e: ZkNodeExistsException => { // this can happen when there is connection loss; make sure the data is what we intend to write var storedData: String = null try { storedData = readData(client, path)._1 } catch { case e1: ZkNoNodeException => // the node disappeared; treat as if node existed and let caller handles this case e2 => throw e2 } if (storedData == null || storedData != data) { info("conflict in " + path + " data: " + data + " stored data: " + storedData) throw e } else { // otherwise, the creation succeeded, return normally info(path + " exists with value " + data + " during connection loss; this is ok") } } case e2 => throw e2 } } /** * Create an persistent node with the given path and data. Create parents if necessary. */ def createPersistentPath(client: ZkClient, path: String, data: String = ""): Unit = { try { client.createPersistent(path, data) } catch { case e: ZkNoNodeException => { createParentPath(client, path) client.createPersistent(path, data) } } } def createSequentialPersistentPath(client: ZkClient, path: String, data: String = ""): String = { client.createPersistentSequential(path, data) } /** * Update the value of a persistent node with the given path and data. * create parrent directory if necessary. Never throw NodeExistException. * Return the updated path zkVersion */ def updatePersistentPath(client: ZkClient, path: String, data: String): Int = { var stat: Stat = null try { stat = client.writeData(path, data) return stat.getVersion } catch { case e: ZkNoNodeException => { createParentPath(client, path) try { client.createPersistent(path, data) // When the new path is created, its zkVersion always starts from 0 return 0 } catch { case e: ZkNodeExistsException => stat = client.writeData(path, data) return stat.getVersion case e2 => throw e2 } } case e2 => throw e2 } } /** * Conditional update the persistent path data, return (true, newVersion) if it succeeds, otherwise (the path doesn't * exist, the current version is not the expected version, etc.) return (false, -1) */ def conditionalUpdatePersistentPath(client: ZkClient, path: String, data: String, expectVersion: Int): (Boolean, Int) = { try { val stat = client.writeData(path, data, expectVersion) info("Conditional update of zkPath %s with value %s and expected version %d succeeded, returning the new version: %d" .format(path, data, expectVersion, stat.getVersion)) (true, stat.getVersion) } catch { case e: Exception => error("Conditional update of zkPath %s with data %s and expected version %d failed".format(path, data, expectVersion), e) (false, -1) } } /** * Conditional update the persistent path data, return (true, newVersion) if it succeeds, otherwise (the current * version is not the expected version, etc.) return (false, -1). If path doesn't exist, throws ZkNoNodeException */ def conditionalUpdatePersistentPathIfExists(client: ZkClient, path: String, data: String, expectVersion: Int): (Boolean, Int) = { try { val stat = client.writeData(path, data, expectVersion) info("Conditional update of zkPath %s with value %s and expected version %d succeeded, returning the new version: %d" .format(path, data, expectVersion, stat.getVersion)) (true, stat.getVersion) } catch { case nne: ZkNoNodeException => throw nne case e: Exception => error("Conditional update of zkPath %s with data %s and expected version %d failed".format(path, data, expectVersion), e) (false, -1) } } /** * Update the value of a persistent node with the given path and data. * create parrent directory if necessary. Never throw NodeExistException. */ def updateEphemeralPath(client: ZkClient, path: String, data: String): Unit = { try { client.writeData(path, data) } catch { case e: ZkNoNodeException => { createParentPath(client, path) client.createEphemeral(path, data) } case e2 => throw e2 } } def deletePath(client: ZkClient, path: String): Boolean = { try { client.delete(path) } catch { case e: ZkNoNodeException => // this can happen during a connection loss event, return normally info(path + " deleted during connection loss; this is ok") false case e2 => throw e2 } } def deletePathRecursive(client: ZkClient, path: String) { try { client.deleteRecursive(path) } catch { case e: ZkNoNodeException => // this can happen during a connection loss event, return normally info(path + " deleted during connection loss; this is ok") case e2 => throw e2 } } def maybeDeletePath(zkUrl: String, dir: String) { try { val zk = new ZkClient(zkUrl, 30*1000, 30*1000, ZKStringSerializer) zk.deleteRecursive(dir) zk.close() } catch { case _ => // swallow } } def readData(client: ZkClient, path: String): (String, Stat) = { val stat: Stat = new Stat() val dataStr: String = client.readData(path, stat) (dataStr, stat) } def readDataMaybeNull(client: ZkClient, path: String): (Option[String], Stat) = { val stat: Stat = new Stat() val dataAndStat = try { (Some(client.readData(path, stat)), stat) } catch { case e: ZkNoNodeException => (None, stat) case e2 => throw e2 } dataAndStat } def getChildren(client: ZkClient, path: String): Seq[String] = { import scala.collection.JavaConversions._ // triggers implicit conversion from java list to scala Seq client.getChildren(path) } def getChildrenParentMayNotExist(client: ZkClient, path: String): Seq[String] = { import scala.collection.JavaConversions._ // triggers implicit conversion from java list to scala Seq try { client.getChildren(path) } catch { case e: ZkNoNodeException => return Nil case e2 => throw e2 } } /** * Check if the given path exists */ def pathExists(client: ZkClient, path: String): Boolean = { client.exists(path) } def getLastPart(path : String) : String = path.substring(path.lastIndexOf('/') + 1) def getCluster(zkClient: ZkClient) : Cluster = { val cluster = new Cluster val nodes = getChildrenParentMayNotExist(zkClient, BrokerIdsPath) for (node <- nodes) { val brokerZKString = readData(zkClient, BrokerIdsPath + "/" + node)._1 cluster.add(Broker.createBroker(node.toInt, brokerZKString)) } cluster } def getReplicaAssignmentForTopics(zkClient: ZkClient, topics: Iterator[String]): mutable.Map[(String, Int), Seq[Int]] = { val ret = new mutable.HashMap[(String, Int), Seq[Int]] topics.foreach { topic => val jsonPartitionMapOpt = readDataMaybeNull(zkClient, getTopicPath(topic))._1 jsonPartitionMapOpt match { case Some(jsonPartitionMap) => Json.parseFull(jsonPartitionMap) match { case Some(m) => val replicaMap = m.asInstanceOf[Map[String, Seq[String]]] for((partition, replicas) <- replicaMap){ ret.put((topic, partition.toInt), replicas.map(_.toInt)) debug("Replicas assigned to topic [%s], partition [%s] are [%s]".format(topic, partition, replicas)) } case None => } case None => } } ret } def getPartitionLeaderAndIsrForTopics(zkClient: ZkClient, topics: Seq[String]): mutable.Map[TopicAndPartition, LeaderIsrAndControllerEpoch] = { val ret = new mutable.HashMap[TopicAndPartition, LeaderIsrAndControllerEpoch] val partitionsForTopics = getPartitionsForTopics(zkClient, topics) for((topic, partitions) <- partitionsForTopics) { for(partition <- partitions) { ZkUtils.getLeaderIsrAndEpochForPartition(zkClient, topic, partition.toInt) match { case Some(leaderIsrAndControllerEpoch) => ret.put(TopicAndPartition(topic, partition.toInt), leaderIsrAndControllerEpoch) case None => } } } ret } def getReplicaAssignmentForTopics(zkClient: ZkClient, topics: Seq[String]): mutable.Map[TopicAndPartition, Seq[Int]] = { val ret = new mutable.HashMap[TopicAndPartition, Seq[Int]] topics.foreach { topic => val jsonPartitionMapOpt = readDataMaybeNull(zkClient, getTopicPath(topic))._1 jsonPartitionMapOpt match { case Some(jsonPartitionMap) => Json.parseFull(jsonPartitionMap) match { case Some(m) => val replicaMap = m.asInstanceOf[Map[String, Seq[String]]] for((partition, replicas) <- replicaMap){ ret.put(TopicAndPartition(topic, partition.toInt), replicas.map(_.toInt)) debug("Replicas assigned to topic [%s], partition [%s] are [%s]".format(topic, partition, replicas)) } case None => } case None => } } ret } def getPartitionAssignmentForTopics(zkClient: ZkClient, topics: Seq[String]): mutable.Map[String, collection.Map[Int, Seq[Int]]] = { val ret = new mutable.HashMap[String, Map[Int, Seq[Int]]]() topics.foreach{ topic => val jsonPartitionMapOpt = readDataMaybeNull(zkClient, getTopicPath(topic))._1 val partitionMap = jsonPartitionMapOpt match { case Some(jsonPartitionMap) => Json.parseFull(jsonPartitionMap) match { case Some(m) => val m1 = m.asInstanceOf[Map[String, Seq[String]]] m1.map(p => (p._1.toInt, p._2.map(_.toInt))) case None => Map[Int, Seq[Int]]() } case None => Map[Int, Seq[Int]]() } debug("Partition map for /brokers/topics/%s is %s".format(topic, partitionMap)) ret += (topic -> partitionMap) } ret } def getReplicaAssignmentFromPartitionAssignment(topicPartitionAssignment: mutable.Map[String, collection.Map[Int, Seq[Int]]]): mutable.Map[(String, Int), Seq[Int]] = { val ret = new mutable.HashMap[(String, Int), Seq[Int]] for((topic, partitionAssignment) <- topicPartitionAssignment){ for((partition, replicaAssignment) <- partitionAssignment){ ret.put((topic, partition), replicaAssignment) } } ret } def getPartitionsForTopics(zkClient: ZkClient, topics: Seq[String]): mutable.Map[String, Seq[Int]] = { getPartitionAssignmentForTopics(zkClient, topics).map { topicAndPartitionMap => val topic = topicAndPartitionMap._1 val partitionMap = topicAndPartitionMap._2 debug("partition assignment of /brokers/topics/%s is %s".format(topic, partitionMap)) (topic -> partitionMap.keys.toSeq.sortWith((s,t) => s < t)) } } def getPartitionsAssignedToBroker(zkClient: ZkClient, topics: Seq[String], brokerId: Int): Seq[(String, Int)] = { val topicsAndPartitions = getPartitionAssignmentForTopics(zkClient, topics) topicsAndPartitions.map { topicAndPartitionMap => val topic = topicAndPartitionMap._1 val partitionMap = topicAndPartitionMap._2 val relevantPartitionsMap = partitionMap.filter( m => m._2.contains(brokerId) ) val relevantPartitions = relevantPartitionsMap.map(_._1) for(relevantPartition <- relevantPartitions) yield { (topic, relevantPartition) } }.flatten[(String, Int)].toSeq } def getPartitionsBeingReassigned(zkClient: ZkClient): Map[TopicAndPartition, ReassignedPartitionsContext] = { // read the partitions and their new replica list val jsonPartitionMapOpt = readDataMaybeNull(zkClient, ReassignPartitionsPath)._1 jsonPartitionMapOpt match { case Some(jsonPartitionMap) => val reassignedPartitions = parsePartitionReassignmentData(jsonPartitionMap) reassignedPartitions.map { p => val newReplicas = p._2 (p._1 -> new ReassignedPartitionsContext(newReplicas)) } case None => Map.empty[TopicAndPartition, ReassignedPartitionsContext] } } def parsePartitionReassignmentData(jsonData: String):Map[TopicAndPartition, Seq[Int]] = { Json.parseFull(jsonData) match { case Some(m) => val replicaMap = m.asInstanceOf[Map[String, Seq[String]]] replicaMap.map { reassignedPartitions => val topic = reassignedPartitions._1.split(",").head val partition = reassignedPartitions._1.split(",").last.toInt val newReplicas = reassignedPartitions._2.map(_.toInt) TopicAndPartition(topic, partition) -> newReplicas } case None => Map.empty[TopicAndPartition, Seq[Int]] } } def updatePartitionReassignmentData(zkClient: ZkClient, partitionsToBeReassigned: Map[TopicAndPartition, Seq[Int]]) { val zkPath = ZkUtils.ReassignPartitionsPath partitionsToBeReassigned.size match { case 0 => // need to delete the /admin/reassign_partitions path deletePath(zkClient, zkPath) info("No more partitions need to be reassigned. Deleting zk path %s".format(zkPath)) case _ => val jsonData = Utils.mapToJson(partitionsToBeReassigned.map(p => ("%s,%s".format(p._1.topic, p._1.partition)) -> p._2.map(_.toString))) try { updatePersistentPath(zkClient, zkPath, jsonData) info("Updated partition reassignment path with %s".format(jsonData)) }catch { case nne: ZkNoNodeException => ZkUtils.createPersistentPath(zkClient, zkPath, jsonData) debug("Created path %s with %s for partition reassignment".format(zkPath, jsonData)) case e2 => throw new AdministrationException(e2.toString) } } } def getAllReplicasOnBroker(zkClient: ZkClient, topics: Seq[String], brokerIds: Seq[Int]): Set[PartitionAndReplica] = { Set.empty[PartitionAndReplica] ++ brokerIds.map { brokerId => // read all the partitions and their assigned replicas into a map organized by // { replica id -> partition 1, partition 2... val partitionsAssignedToThisBroker = getPartitionsAssignedToBroker(zkClient, topics, brokerId) if(partitionsAssignedToThisBroker.size == 0) info("No state transitions triggered since no partitions are assigned to brokers %s".format(brokerIds.mkString(","))) partitionsAssignedToThisBroker.map(p => new PartitionAndReplica(p._1, p._2, brokerId)) }.flatten } def getPartitionsUndergoingPreferredReplicaElection(zkClient: ZkClient): Set[TopicAndPartition] = { // read the partitions and their new replica list val jsonPartitionListOpt = readDataMaybeNull(zkClient, PreferredReplicaLeaderElectionPath)._1 jsonPartitionListOpt match { case Some(jsonPartitionList) => parsePreferredReplicaElectionData(jsonPartitionList) case None => Set.empty[TopicAndPartition] } } def parsePreferredReplicaElectionData(jsonData: String):Set[TopicAndPartition] = { Json.parseFull(jsonData) match { case Some(m) => val topicAndPartitions = m.asInstanceOf[Array[Map[String, String]]] val partitions = topicAndPartitions.map { p => val topicPartitionMap = p.asInstanceOf[Map[String, String]] val topic = topicPartitionMap.get("topic").get val partition = topicPartitionMap.get("partition").get.toInt TopicAndPartition(topic, partition) } Set.empty[TopicAndPartition] ++ partitions case None => Set.empty[TopicAndPartition] } } def deletePartition(zkClient : ZkClient, brokerId: Int, topic: String) { val brokerIdPath = BrokerIdsPath + "/" + brokerId zkClient.delete(brokerIdPath) val brokerPartTopicPath = BrokerTopicsPath + "/" + topic + "/" + brokerId zkClient.delete(brokerPartTopicPath) } def getConsumersInGroup(zkClient: ZkClient, group: String): Seq[String] = { val dirs = new ZKGroupDirs(group) getChildren(zkClient, dirs.consumerRegistryDir) } def getConsumersPerTopic(zkClient: ZkClient, group: String) : mutable.Map[String, List[String]] = { val dirs = new ZKGroupDirs(group) val consumers = getChildrenParentMayNotExist(zkClient, dirs.consumerRegistryDir) val consumersPerTopicMap = new mutable.HashMap[String, List[String]] for (consumer <- consumers) { val topicCount = TopicCount.constructTopicCount(group, consumer, zkClient) for ((topic, consumerThreadIdSet) <- topicCount.getConsumerThreadIdsPerTopic) { for (consumerThreadId <- consumerThreadIdSet) consumersPerTopicMap.get(topic) match { case Some(curConsumers) => consumersPerTopicMap.put(topic, consumerThreadId :: curConsumers) case _ => consumersPerTopicMap.put(topic, List(consumerThreadId)) } } } for ( (topic, consumerList) <- consumersPerTopicMap ) consumersPerTopicMap.put(topic, consumerList.sortWith((s,t) => s < t)) consumersPerTopicMap } /** * This API takes in a broker id, queries zookeeper for the broker metadata and returns the metadata for that broker * or throws an exception if the broker dies before the query to zookeeper finishes * @param brokerId The broker id * @param zkClient The zookeeper client connection * @return An optional Broker object encapsulating the broker metadata */ def getBrokerInfo(zkClient: ZkClient, brokerId: Int): Option[Broker] = { ZkUtils.readDataMaybeNull(zkClient, ZkUtils.BrokerIdsPath + "/" + brokerId)._1 match { case Some(brokerInfo) => Some(Broker.createBroker(brokerId, brokerInfo)) case None => None } } def getAllTopics(zkClient: ZkClient): Seq[String] = { val topics = ZkUtils.getChildrenParentMayNotExist(zkClient, BrokerTopicsPath) if(topics == null) Seq.empty[String] else topics } def getAllPartitions(zkClient: ZkClient): Set[TopicAndPartition] = { val topics = ZkUtils.getChildrenParentMayNotExist(zkClient, BrokerTopicsPath) if(topics == null) Set.empty[TopicAndPartition] else { topics.map { topic => getChildren(zkClient, getTopicPartitionsPath(topic)).map(_.toInt).map(TopicAndPartition(topic, _)) }.flatten.toSet } } } class LeaderExistsOrChangedListener(topic: String, partition: Int, leaderLock: ReentrantLock, leaderExistsOrChanged: Condition, oldLeaderOpt: Option[Int] = None, zkClient: ZkClient = null) extends IZkDataListener with Logging { @throws(classOf[Exception]) def handleDataChange(dataPath: String, data: Object) { val t = dataPath.split("/").takeRight(3).head val p = dataPath.split("/").takeRight(2).head.toInt leaderLock.lock() try { if(t == topic && p == partition){ if(oldLeaderOpt == None){ trace("In leader existence listener on partition [%s, %d], leader has been created".format(topic, partition)) leaderExistsOrChanged.signal() } else { val newLeaderOpt = ZkUtils.getLeaderForPartition(zkClient, t, p) if(newLeaderOpt.isDefined && newLeaderOpt.get != oldLeaderOpt.get){ trace("In leader change listener on partition [%s, %d], leader has been moved from %d to %d".format(topic, partition, oldLeaderOpt.get, newLeaderOpt.get)) leaderExistsOrChanged.signal() } } } } finally { leaderLock.unlock() } } @throws(classOf[Exception]) def handleDataDeleted(dataPath: String) { leaderLock.lock() try { leaderExistsOrChanged.signal() }finally { leaderLock.unlock() } } } object ZKStringSerializer extends ZkSerializer { @throws(classOf[ZkMarshallingError]) def serialize(data : Object) : Array[Byte] = data.asInstanceOf[String].getBytes("UTF-8") @throws(classOf[ZkMarshallingError]) def deserialize(bytes : Array[Byte]) : Object = { if (bytes == null) null else new String(bytes, "UTF-8") } } class ZKGroupDirs(val group: String) { def consumerDir = ZkUtils.ConsumersPath def consumerGroupDir = consumerDir + "/" + group def consumerRegistryDir = consumerGroupDir + "/ids" } class ZKGroupTopicDirs(group: String, topic: String) extends ZKGroupDirs(group) { def consumerOffsetDir = consumerGroupDir + "/offsets/" + topic def consumerOwnerDir = consumerGroupDir + "/owners/" + topic } class ZKConfig(props: VerifiableProperties) { /** ZK host string */ val zkConnect = props.getString("zk.connect", null) /** zookeeper session timeout */ val zkSessionTimeoutMs = props.getInt("zk.sessiontimeout.ms", 6000) /** the max time that the client waits to establish a connection to zookeeper */ val zkConnectionTimeoutMs = props.getInt("zk.connectiontimeout.ms",zkSessionTimeoutMs) /** how far a ZK follower can be behind a ZK leader */ val zkSyncTimeMs = props.getInt("zk.synctime.ms", 2000) }
dchenbecker/kafka-sbt
core/src/main/scala/kafka/utils/ZkUtils.scala
Scala
apache-2.0
32,076
package com.arcusys.learn.liferay.update import com.arcusys.learn.liferay.LiferayClasses.LUpgradeProcess class DBUpdater220 extends LUpgradeProcess with SQLRunner { override def getThreshold = 220 override def doUpgrade() { System.out.println("Updating to 2.2") // update tincan table columns length runSQLScript("""alter table Learn_LFTincanManifestAct alter column "tincanid" TYPE VARCHAR(2000);""".stripMargin) runSQLScript("""alter table Learn_LFTincanManifestAct alter column "description" TYPE VARCHAR(2000);""".stripMargin) runSQLScript("""alter table Learn_LFTincanManifestAct alter column "resourceid" TYPE VARCHAR(2000);""".stripMargin) runSQLScript("""alter table Learn_LFTincanManifestAct alter column "activitytype" TYPE VARCHAR(2000);""".stripMargin) runSQLScript("""alter table Learn_LFTincanManifestAct alter column "launch" TYPE VARCHAR(2000);""".stripMargin) runSQLScript("""alter table Learn_LFTincanManifestAct alter column "name" TYPE VARCHAR(2000);""".stripMargin) // rename table passinglimit -> lessonlimit runSQLScript("""ALTER TABLE Learn_LFPassingLimit RENAME TO Learn_LFLessonLimit;""".stripMargin) // rename table Learn_LFCertificateTincanStatement -> Learn_LFCertTCStmnt runSQLScript("""ALTER TABLE Learn_LFCertificateTincanStatement RENAME TO Learn_LFCertTCStmnt;""".stripMargin) // rename table Learn_LFGlobalObjectiveState -> Learn_LFGlblObjectiveState runSQLScript("""ALTER TABLE Learn_LFGlobalObjectiveState RENAME TO Learn_LFGlblObjectiveState;""".stripMargin) // rename table Learn_LFQuizQuestionCategory -> Learn_LFQuizQuestCat runSQLScript("""ALTER TABLE Learn_LFQuizQuestionCategory RENAME TO Learn_LFQuizQuestCat;""".stripMargin) // rename table Learn_LFSequencingPermissions -> Learn_LFSeqPermissions runSQLScript("""ALTER TABLE Learn_LFSequencingPermissions RENAME TO Learn_LFSeqPermissions;""".stripMargin) // rename table Learn_LFTincanClientApiStorage -> Learn_LFTCClntApiStorage runSQLScript("""ALTER TABLE Learn_LFTincanClientApiStorage RENAME TO Learn_LFTCClntApiStorage;""".stripMargin) // rename table Learn_LFTincanLrsAgentProfile -> Learn_LFTCLrsAgentProfile runSQLScript("""ALTER TABLE Learn_LFTincanLrsAgentProfile RENAME TO Learn_LFTCLrsAgentProfile;""".stripMargin) // rename table Learn_LFTincanLrsStatementRef -> Learn_LFTCLrsStmntRef runSQLScript("""ALTER TABLE Learn_LFTincanLrsStatementRef RENAME TO Learn_LFTCLrsStmntRef;""".stripMargin) // rename table Learn_LFTincanLrsSubStatement -> Learn_LFTCLrsSubStmnt runSQLScript("""ALTER TABLE Learn_LFTincanLrsSubStatement RENAME TO Learn_LFTCLrsSubStmnt;""".stripMargin) // add columns to lessonlimit runSQLScript("""ALTER TABLE Learn_lflessonlimit RENAME column itemValue TO passingLimit;""".stripMargin) runSQLScript("""ALTER TABLE Learn_lflessonlimit ADD COLUMN rerunInterval INTEGER null;""".stripMargin) runSQLScript("""ALTER TABLE Learn_lflessonlimit ADD COLUMN rerunIntervalType VARCHAR(75) null;""".stripMargin) // add columns to quiz runSQLScript("""alter table Learn_lfquiz add column maxDuration INTEGER null;""".stripMargin) runSQLScript("""alter table Learn_lfquizquestion add column groupId INTEGER null;""".stripMargin) //Learn_LFCertTCStmnt runSQLScript("""alter table Learn_LFCertTCStmnt alter column "verb" TYPE VARCHAR(1024);""".stripMargin) runSQLScript("""alter table Learn_LFCertTCStmnt alter column "object" TYPE VARCHAR(4096);""".stripMargin) runSQLScript("""alter table Learn_LFCertTCStmnt alter column "periodType" TYPE VARCHAR(512);""".stripMargin) //Learn_LFAchievement runSQLScript("""alter table Learn_LFAchievement alter column "title" TYPE VARCHAR(512);""".stripMargin) //Learn_LFBigDecimal runSQLScript("""alter table Learn_LFBigDecimal alter column "text_" TYPE VARCHAR(512);""".stripMargin) //Learn_LFCertificate runSQLScript("""alter table Learn_LFCertificate alter column "logo" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFCertificate alter column "shortDescription" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFCertificate alter column "state_" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFCertificate alter column "emails" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFCertificate alter column "validPeriodType" TYPE VARCHAR(512);""".stripMargin) //Learn_LFCertificateActivity runSQLScript("""alter table Learn_LFCertificateActivity alter column "activityName" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFCertificateActivity alter column "periodType" TYPE VARCHAR(512);""".stripMargin) //Learn_LFCertificateCourse runSQLScript("""alter table Learn_LFCertificateCourse alter column "periodType" TYPE VARCHAR(512);""".stripMargin) //Learn_LFConfig runSQLScript("""alter table Learn_LFConfig alter column "dataKey" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFConfig alter column "dataValue" TYPE VARCHAR(512);""".stripMargin) //Learn_LFLRSToActSettng runSQLScript("""alter table Learn_LFLRSToActivitySetting alter column "title" TYPE VARCHAR(512);""".stripMargin) //Learn_LFLessonLimit runSQLScript("""alter table Learn_LFLessonLimit alter column "itemType" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFLessonLimit alter column "rerunIntervalType" TYPE VARCHAR(512);""".stripMargin) //Learn_LFPackageComment runSQLScript("""alter table Learn_LFPackageComment alter column "comment_" TYPE VARCHAR(512);""".stripMargin) //Learn_LFPackageGradeStorage runSQLScript("""alter table Learn_LFPackageGradeStorage alter column "grade" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFPackageGradeStorage alter column "comment_" TYPE VARCHAR(512);""".stripMargin) //Learn_LFQuiz runSQLScript("""alter table Learn_LFQuiz alter column "logo" TYPE VARCHAR(512);""".stripMargin) //Learn_LFQuizTreeElement runSQLScript("""alter table Learn_LFQuizTreeElement alter column "elementID" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFQuizTreeElement alter column "parentID" TYPE VARCHAR(512);""".stripMargin) //Learn_LFRequiredActivity runSQLScript("""alter table Learn_LFRequiredActivity alter column "activityClassName" TYPE VARCHAR(512);""".stripMargin) //Learn_LFRole runSQLScript("""alter table Learn_LFRole alter column "permission" TYPE VARCHAR(512);""".stripMargin) //Learn_LFSiteDependentConfig runSQLScript("""alter table Learn_LFSiteDependentConfig alter column "dataKey" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFSiteDependentConfig alter column "dataValue" TYPE VARCHAR(512);""".stripMargin) //Learn_LFSocialPackageTag runSQLScript("""alter table Learn_LFSocialPackageTag alter column "name" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanActProfile runSQLScript("""alter table Learn_LFTincanActProfile alter column "activityId" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTincanActProfile alter column "profileId" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanActivity runSQLScript("""alter table Learn_LFTincanActivity alter column "objectType" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanActor runSQLScript("""alter table Learn_LFTincanActor alter column "tincanID" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTincanActor alter column "objectType" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTCClntApiStorage runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "name" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "description" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "secret" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "url" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "redirectUrl" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "scope" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "iconUrl" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "token" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTCClntApiStorage alter column "code_" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTCLrsAgentProfile runSQLScript("""alter table Learn_LFTCLrsAgentProfile alter column "profileId" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanLrsContext runSQLScript("""alter table Learn_LFTincanLrsContext alter column "registration" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanLrsDocument runSQLScript("""alter table Learn_LFTincanLrsDocument alter column "documentId" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanLrsResult runSQLScript("""alter table Learn_LFTincanLrsResult alter column "duration" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanLrsState runSQLScript("""alter table Learn_LFTincanLrsState alter column "stateId" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTincanLrsState alter column "documentId" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTincanLrsState alter column "activityId" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanLrsStatement runSQLScript("""alter table Learn_LFTincanLrsStatement alter column "tincanID" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTCLrsStmntRef runSQLScript("""alter table Learn_LFTCLrsStmntRef alter column "uuid_" TYPE VARCHAR(512);""".stripMargin) //Learn_LFTincanURI runSQLScript("""alter table Learn_LFTincanURI alter column "objID" TYPE VARCHAR(512);""".stripMargin) runSQLScript("""alter table Learn_LFTincanURI alter column "objType" TYPE VARCHAR(512);""".stripMargin) } }
ViLPy/Valamis
learn-portlet/src/main/scala/com/arcusys/learn/liferay/update/DBUpdater220.scala
Scala
lgpl-3.0
10,313
package util import javax.crypto.SecretKeyFactory import javax.crypto.spec.PBEKeySpec import org.joda.time.DateTime /** * パスワード暗号化の共通クラス. */ object PasswordDigestUtil { /** * Hash文字列作成. * @param passwordStr ユーザ入力パスワード文字列 * @param timeStamp パスワード用日時 * @return Hash化文字列 */ def createHashPassword(passwordStr: String, timeStamp: DateTime): String = { val passChars = passwordStr.toCharArray val solt = (timeStamp.toString(ConfigHelper.soltFormat) + ConfigHelper.pepper).getBytes val keySpec = new PBEKeySpec(passChars, solt, ConfigHelper.stretching, 256) val skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512") val secretKey = skf.generateSecret(keySpec) secretKey.getEncoded.map("%02X" format _).mkString } }
nemuzuka/vss-kanban
src/main/scala/util/PasswordDigestUtil.scala
Scala
mit
854
/* * Copyright 2016 The BigDL Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.intel.analytics.bigdl.models import com.intel.analytics.bigdl.models.inception._ import com.intel.analytics.bigdl.nn.{Graph, Input} import com.intel.analytics.bigdl.numeric.NumericFloat import com.intel.analytics.bigdl.tensor.Tensor import com.intel.analytics.bigdl.utils.RandomGenerator._ import com.intel.analytics.bigdl.utils.{T, Table} import org.scalatest.{FlatSpec, Matchers} import scala.util.Random @com.intel.analytics.bigdl.tags.Serial class InceptionSpec extends FlatSpec with Matchers { "Inception_Layer_V1 graph" should "be correct" in { val batchSize = 8 RNG.setSeed(1000) val model = Inception_Layer_v1(2, T(T(4), T(96, 128), T(16, 32), T(32)), "conv") RNG.setSeed(1000) val input = Input() val f1 = Inception_Layer_v1(input, 2, T(T(4), T(96, 128), T(16, 32), T(32)), "conv") val graphModel = Graph(input, f1) val inputData = Tensor(batchSize, 2, 4, 4).rand() val gradOutput = Tensor(batchSize, 256, 4, 4).rand() val output1 = model.forward(inputData).toTensor[Float] val output2 = graphModel.forward(inputData).toTensor[Float] output1 should be(output2) val gradInput1 = model.backward(inputData, gradOutput).toTensor[Float] val gradInput2 = graphModel.backward(inputData, gradOutput).toTensor[Float] gradInput1 should be(gradInput2) model.getParametersTable()[Table]("conv1x1")[Tensor[Float]]("gradWeight") should be( graphModel.getParametersTable()[Table]("conv1x1")[Tensor[Float]]("gradWeight") ) model.getParametersTable()[Table]("conv3x3_reduce")[Tensor[Float]]("gradWeight") should be( graphModel.getParametersTable()[Table]("conv3x3_reduce")[Tensor[Float]]("gradWeight") ) model.getParametersTable()[Table]("conv3x3")[Tensor[Float]]("gradWeight") should be( graphModel.getParametersTable()[Table]("conv3x3")[Tensor[Float]]("gradWeight") ) model.getParametersTable()[Table]("conv5x5_reduce")[Tensor[Float]]("gradWeight") should be( graphModel.getParametersTable()[Table]("conv5x5_reduce")[Tensor[Float]]("gradWeight") ) model.getParametersTable()[Table]("conv5x5")[Tensor[Float]]("gradWeight") should be( graphModel.getParametersTable()[Table]("conv5x5")[Tensor[Float]]("gradWeight") ) model.getParametersTable()[Table]("convpool_proj")[Tensor[Float]]("gradWeight") should be( graphModel.getParametersTable()[Table]("convpool_proj")[Tensor[Float]]("gradWeight") ) } "Inception graph" should "be correct" in { val batchSize = 2 RNG.setSeed(1000) val model = Inception_v1_NoAuxClassifier(1000, false) RNG.setSeed(1000) val graphModel = Inception_v1_NoAuxClassifier.graph(1000, false) val input = Tensor[Float](batchSize, 3, 224, 224).apply1(e => Random.nextFloat()) val gradOutput = Tensor[Float](batchSize, 1000).apply1(e => Random.nextFloat()) val output1 = model.forward(input).toTensor[Float] val output2 = graphModel.forward(input).toTensor[Float] output1 should be(output2) val gradInput1 = model.backward(input, gradOutput).toTensor[Float] val gradInput2 = graphModel.backward(input, gradOutput).toTensor[Float] gradInput1 should be(gradInput2) val table1 = model.getParametersTable() val table2 = graphModel.getParametersTable() table1.keySet.foreach(key => { table1(key).asInstanceOf[Table]("weight").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("weight").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("bias").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("bias").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("gradWeight").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("gradWeight").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("gradBias").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("gradBias").asInstanceOf[Tensor[Float]] }) } "Inception_v1 graph" should "be correct" in { val batchSize = 1 RNG.setSeed(1000) val model = Inception_v1(1000, false) RNG.setSeed(1000) val graphModel = Inception_v1.graph(1000, false) val input = Tensor[Float](batchSize, 3, 224, 224).apply1(e => Random.nextFloat()) val gradOutput = Tensor[Float](batchSize, 3000).apply1(e => Random.nextFloat()) val output1 = model.forward(input).toTensor[Float] val output2 = graphModel.forward(input).toTensor[Float] output1 should be(output2) val gradInput1 = model.backward(input, gradOutput) val gradInput2 = graphModel.backward(input, gradOutput) gradInput1 should be(gradInput2) } "Inception_Layer_V2 graph" should "be correct" in { val batchSize = 8 RNG.setSeed(1000) val model = Inception_Layer_v2(2, T(T(4), T(96, 128), T(16, 32), T("avg", 32)), "conv") RNG.setSeed(1000) val input1 = Input() val f1 = Inception_Layer_v2(input1, 2, T(T(4), T(96, 128), T(16, 32), T("avg", 32)), "conv") val graphModel = Graph(input1, f1) val input = Tensor(batchSize, 2, 4, 4).rand() val gradOutput = Tensor(batchSize, 256, 4, 4).rand() val output1 = model.forward(input).toTensor[Float] val output2 = graphModel.forward(input).toTensor[Float] output1 should be(output2) val gradInput1 = model.backward(input, gradOutput).toTensor[Float] val gradInput2 = graphModel.backward(input, gradOutput).toTensor[Float] gradInput1 should be(gradInput2) val table1 = model.getParametersTable() val table2 = graphModel.getParametersTable() table1.keySet.foreach(key => { table1(key).asInstanceOf[Table]("weight").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("weight").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("bias").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("bias").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("gradWeight").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("gradWeight").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("gradBias").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("gradBias").asInstanceOf[Tensor[Float]] }) } "Inception_v2_NoAuxClassifier graph" should "be correct" in { val batchSize = 2 RNG.setSeed(1000) val model = Inception_v2_NoAuxClassifier(1000) RNG.setSeed(1000) val graphModel = Inception_v2_NoAuxClassifier.graph(1000) val input = Tensor[Float](batchSize, 3, 224, 224).apply1(e => Random.nextFloat()) val gradOutput = Tensor[Float](batchSize, 1000).apply1(e => Random.nextFloat()) val output1 = model.forward(input).toTensor[Float] val output2 = graphModel.forward(input).toTensor[Float] output1 should be(output2) val gradInput1 = model.backward(input, gradOutput).toTensor[Float] val gradInput2 = graphModel.backward(input, gradOutput).toTensor[Float] gradInput1 should be(gradInput2) val table1 = model.getParametersTable() val table2 = graphModel.getParametersTable() table1.keySet.foreach(key => { table1(key).asInstanceOf[Table]("weight").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("weight").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("bias").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("bias").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("gradWeight").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("gradWeight").asInstanceOf[Tensor[Float]] table1(key).asInstanceOf[Table]("gradBias").asInstanceOf[Tensor[Float]] should be table2(key).asInstanceOf[Table]("gradBias").asInstanceOf[Tensor[Float]] }) } "Inception_v2 graph" should "be correct" in { val batchSize = 2 RNG.setSeed(1000) val model = Inception_v2(1000) RNG.setSeed(1000) val graphModel = Inception_v2.graph(1000) val input = Tensor[Float](batchSize, 3, 224, 224).apply1(e => Random.nextFloat()) val gradOutput = Tensor[Float](batchSize, 3000).apply1(e => Random.nextFloat()) val output1 = model.forward(input).toTensor[Float] val output2 = graphModel.forward(input).toTensor[Float] output1 should be(output2) val gradInput1 = model.updateGradInput(input, gradOutput) val gradInput2 = graphModel.updateGradInput(input, gradOutput) gradInput1 should be(gradInput2) } }
zhangxiaoli73/BigDL
spark/dl/src/test/scala/com/intel/analytics/bigdl/models/InceptionSpec.scala
Scala
apache-2.0
9,135
/** Copyright 2015 TappingStone, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package io.prediction.data.storage.elasticsearch import grizzled.slf4j.Logging import org.elasticsearch.client.Client import org.elasticsearch.client.transport.TransportClient import org.elasticsearch.common.transport.InetSocketTransportAddress import org.elasticsearch.transport.ConnectTransportException import io.prediction.data.storage.BaseStorageClient import io.prediction.data.storage.StorageClientConfig import io.prediction.data.storage.StorageClientException class StorageClient(val config: StorageClientConfig) extends BaseStorageClient with Logging { override val prefix = "ES" val client = try { val transportClient = new TransportClient() (config.hosts zip config.ports) foreach { hp => transportClient.addTransportAddress( new InetSocketTransportAddress(hp._1, hp._2)) } transportClient } catch { case e: ConnectTransportException => throw new StorageClientException(e.getMessage) } }
nvoron23/PredictionIO
data/src/main/scala/io/prediction/data/storage/elasticsearch/StorageClient.scala
Scala
apache-2.0
1,569
/* * Copyright (C) 2012 Pavel Fatin <http://pavelfatin.com> * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package com.pavelfatin.fs package manager private case class Step(index: Int, name: String)
pavelfatin/toyfs
src/main/scala/com/pavelfatin/fs/manager/Step.scala
Scala
gpl-3.0
808
package app.agent import app.server.ProbeSummaryResponse import app.ui.BigSpinner import im.mange.jetboot._ import im.mange.jetpac._ case class ChecksSummaryAgent() extends Renderable { private val holder = div(Some("checksSummary")).classes("hidden").styles(marginTop("5px")) def render = holder.render def requestSummary = holder.show & holder.fill(BigSpinner("checksSummarySpinner", "Loading checks summary...")) def show(response: ProbeSummaryResponse) = holder.fill(ChecksConfigPresentation(response.probes)) def hide = holder.empty & holder.hide }
alltonp/reprobate
src/main/scala/app/agent/ChecksSummaryAgent.scala
Scala
apache-2.0
566
class Position(val foo: Int) extends AnyVal { def orElse(that: Position) = if (foo != 0) this else that }
som-snytt/dotty
tests/pos/vcif.scala
Scala
apache-2.0
112
import slick.driver.JdbcProfile import scala.concurrent.{Future, Await} import scala.concurrent.ExecutionContext.Implicits.global import scala.concurrent.duration.Duration import slick.backend.{DatabaseConfig, StaticDatabaseConfig} @StaticDatabaseConfig("#tsql") object TypedSQL extends App { val dc = DatabaseConfig.forAnnotation[JdbcProfile] import dc.driver.api._ def getSuppliers(id: Int): DBIO[Seq[(Int, String, String, String, String, String)]] = tsql"select * from suppliers where id > $id" val db = dc.db try { val a: DBIO[Unit] = getSuppliers(50).map { s => println("All suppliers > 50:") s.foreach(println) } val f: Future[Unit] = db.run(a) Await.result(f, Duration.Inf) } finally db.close }
nafg/slick
samples/slick-plainsql/src/main/scala/TypedSQL.scala
Scala
bsd-2-clause
764
package org.jetbrains.plugins.scala.lang.psi.stubs.index import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import com.intellij.psi.stubs.StringStubIndexExtension import org.jetbrains.plugins.scala.finder.ScalaSourceFilterScope import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.ScObject /** * @author Alexander Podkhalyuzin */ class ScImplicitObjectKey extends StringStubIndexExtension[ScObject] { override def get(fqn: String, project: Project, scope: GlobalSearchScope): java.util.Collection[ScObject] = super.get(fqn, project, new ScalaSourceFilterScope(scope, project)) def getKey = ScImplicitObjectKey.KEY } object ScImplicitObjectKey { val KEY = ScalaIndexKeys.IMPLICIT_OBJECT_KEY }
LPTK/intellij-scala
src/org/jetbrains/plugins/scala/lang/psi/stubs/index/ScImplicitObjectKey.scala
Scala
apache-2.0
763
trait V { // ok // error: java.lang.IllegalArgumentException: Could not find proxy for val f: Function1 in List(value f, value v, trait V, package <empty>, package <root>) (currentOwner= value <local V$class> ) val v = { val f = (x: Int) => x + 1; f(2) } // ok // assertion failed: // Trying to access the this of another class: tree.symbol = trait V, class symbol = object V$class compilation unit: fields.scala val developmentVersion = for { v <- scalaPropOrNone("maven.version.number") if v endsWith "-SNAPSHOT" ov <- scalaPropOrNone("version.number") } yield ov def scalaPropOrNone(name: String): Option[String] = ??? } object O extends V
scala/scala
test/files/pos/trait_fields_owners.scala
Scala
apache-2.0
690
/* * Copyright 2001-2013 Artima, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.scalatest.path import org.scalatest._ import SharedHelpers._ import org.scalatest.path.{ FunSpec => PathFunSpec } import org.scalatest.events._ import org.scalatest.exceptions.TestFailedException import org.scalatest.exceptions.TestCanceledException import org.scalatest.exceptions.DuplicateTestNameException import org.scalatest.exceptions.TestRegistrationClosedException import org.scalatest.exceptions.NotAllowedException import java.lang.annotation.AnnotationFormatError import java.awt.AWTError import java.nio.charset.CoderMalfunctionError import javax.xml.parsers.FactoryConfigurationError import javax.xml.transform.TransformerFactoryConfigurationError class FunSpecSpec extends org.scalatest.FreeSpec with GivenWhenThen { "A path.FunSpec" - { "should return the test names in registration order from testNames" in { class AFunSpec extends PathFunSpec { it("should test this") {} it("should test that") {} override def newInstance = new AFunSpec } val a = new AFunSpec assertResult(List("should test this", "should test that")) { a.testNames.iterator.toList } val b = new PathFunSpec {} assertResult(List[String]()) { b.testNames.iterator.toList } class CFunSpec extends PathFunSpec { it("should test that") {} it("should test this") {} override def newInstance = new CFunSpec } val c = new CFunSpec assertResult(List("should test that", "should test this")) { c.testNames.iterator.toList } class DFunSpec extends PathFunSpec { describe("A Tester") { it("should test that") {} it("should test this") {} } override def newInstance = new DFunSpec } val d = new DFunSpec assertResult(List("A Tester should test that", "A Tester should test this")) { d.testNames.iterator.toList } class EFunSpec extends PathFunSpec { describe("A Tester") { it("should test this") {} it("should test that") {} } override def newInstance = new EFunSpec } val e = new EFunSpec assertResult(List("A Tester should test this", "A Tester should test that")) { e.testNames.iterator.toList } } "should throw DuplicateTestNameException if a duplicate test name registration is attempted" in { intercept[DuplicateTestNameException] { class AFunSpec extends PathFunSpec { it("should test this") {} it("should test this") {} override def newInstance = new AFunSpec } (new AFunSpec).tags // Must call a method to get it to attempt to register the second test } intercept[DuplicateTestNameException] { class AFunSpec extends PathFunSpec { it("should test this") {} ignore("should test this") {} override def newInstance = new AFunSpec } (new AFunSpec).tags } intercept[DuplicateTestNameException] { class AFunSpec extends PathFunSpec { ignore("should test this") {} ignore("should test this") {} override def newInstance = new AFunSpec } (new AFunSpec).tags } intercept[DuplicateTestNameException] { class AFunSpec extends PathFunSpec { ignore("should test this") {} it("should test this") {} override def newInstance = new AFunSpec } (new AFunSpec).tags } } "should create new instance as FunSpecLike" in { val spec = new ExampleFunSpecLike assert(spec.newInstance.isInstanceOf[FunSpecLike]) } "(with info calls)" - { class InfoInsideTestSpec extends PathFunSpec { val msg = "hi there, dude" val testName = "test name" it(testName) { info(msg) } override def newInstance = new InfoInsideTestSpec } // In a Spec, any InfoProvided's fired during the test should be cached and sent out after the test has // suceeded or failed. This makes the report look nicer, because the info is tucked under the "specifier' // text for that test. "should, when the info appears in the code of a successful test, report the info in the TestSucceeded" in { val spec = new InfoInsideTestSpec val (testStartingIndex, testSucceededIndex) = getIndexesForTestInformerEventOrderTests(spec, spec.testName, spec.msg) assert(testStartingIndex < testSucceededIndex) } class InfoBeforeTestSpec extends PathFunSpec { val msg = "hi there, dude" val testName = "test name" info(msg) it(testName) {} } "should, when the info appears in the body before a test, report the info before the test" in { val spec = new InfoBeforeTestSpec val (infoProvidedIndex, testStartingIndex, testSucceededIndex) = getIndexesForInformerEventOrderTests(spec, spec.testName, spec.msg) assert(infoProvidedIndex < testStartingIndex) assert(testStartingIndex < testSucceededIndex) } "should, when the info appears in the body after a test, report the info after the test runs" in { val msg = "hi there, dude" val testName = "test name" class MySpec extends PathFunSpec { it(testName) {} info(msg) } val (infoProvidedIndex, testStartingIndex, testSucceededIndex) = getIndexesForInformerEventOrderTests(new MySpec, testName, msg) assert(testStartingIndex < testSucceededIndex) assert(testSucceededIndex < infoProvidedIndex) } "should print to stdout when info is called by a method invoked after the suite has been executed" in { class MySpec extends PathFunSpec { callInfo() // This should work fine def callInfo() { info("howdy") } it("howdy also") { callInfo() // This should work fine } override def newInstance = new MySpec } val spec = new MySpec val myRep = new EventRecordingReporter spec.run(None, Args(myRep)) spec.callInfo() // TODO: Actually test that This prints to stdout } "should send an InfoProvided with an IndentedText formatter with level 1 when called outside a test" in { val spec = new InfoBeforeTestSpec val indentedText = getIndentedTextFromInfoProvided(spec) assert(indentedText === IndentedText("+ " + spec.msg, spec.msg, 0)) } "should send an InfoProvided with an IndentedText formatter with level 2 when called within a test" in { val spec = new InfoInsideTestSpec val indentedText = getIndentedTextFromTestInfoProvided(spec) assert(indentedText === IndentedText(" + " + spec.msg, spec.msg, 1)) } } "(when a nesting rule has been violated)" - { "should, if they call a describe from within an it clause, result in a TestFailedException when running the test" in { class MySpec extends PathFunSpec { it("should blow up") { describe("in the wrong place, at the wrong time") { } } override def newInstance = new MySpec } val spec = new MySpec ensureTestFailedEventReceived(spec, "should blow up") } "should, if they call a describe with a nested it from within an it clause, result in a TestFailedException when running the test" in { class MySpec extends PathFunSpec { it("should blow up") { describe("in the wrong place, at the wrong time") { it("should never run") { assert(1 === 1) } } } override def newInstance = new MySpec } val spec = new MySpec ensureTestFailedEventReceived(spec, "should blow up") } "should, if they call a nested it from within an it clause, result in a TestFailedException when running the test" in { class MySpec extends PathFunSpec { it("should blow up") { it("should never run") { assert(1 === 1) } } override def newInstance = new MySpec } val spec = new MySpec ensureTestFailedEventReceived(spec, "should blow up") } "should, if they call a nested it with tags from within an it clause, result in a TestFailedException when running the test" in { class MySpec extends PathFunSpec { it("should blow up") { it("should never run", mytags.SlowAsMolasses) { assert(1 === 1) } } override def newInstance = new MySpec } val spec = new MySpec ensureTestFailedEventReceived(spec, "should blow up") } "should, if they call a describe with a nested ignore from within an it clause, result in a TestFailedException when running the test" in { class MySpec extends PathFunSpec { it("should blow up") { describe("in the wrong place, at the wrong time") { ignore("should never run") { assert(1 === 1) } } } override def newInstance = new MySpec } val spec = new MySpec ensureTestFailedEventReceived(spec, "should blow up") } "should, if they call a nested ignore from within an it clause, result in a TestFailedException when running the test" in { class MySpec extends PathFunSpec { it("should blow up") { ignore("should never run") { assert(1 === 1) } } override def newInstance = new MySpec } val spec = new MySpec ensureTestFailedEventReceived(spec, "should blow up") } "should, if they call a nested ignore with tags from within an it clause, result in a TestFailedException when running the test" in { class MySpec extends PathFunSpec { it("should blow up") { ignore("should never run", mytags.SlowAsMolasses) { assert(1 === 1) } } override def newInstance = new MySpec } val spec = new MySpec ensureTestFailedEventReceived(spec, "should blow up") } } "should run tests registered via the 'it should behave like' syntax" in { trait SharedSpecTests { this: PathFunSpec => def nonEmptyStack(s: String)(i: Int) { it("should be that I am shared") {} } } class MySpec extends PathFunSpec with SharedSpecTests { it should behave like nonEmptyStack("hi")(1) override def newInstance = new MySpec } val suite = new MySpec val reporter = new EventRecordingReporter suite.run(None, Args(reporter)) val indexedList = reporter.eventsReceived val testStartingOption = indexedList.find(_.isInstanceOf[TestStarting]) assert(testStartingOption.isDefined) assert(testStartingOption.get.asInstanceOf[TestStarting].testName === "should be that I am shared") } "should throw NullPointerException if a null test tag is provided" in { // it intercept[NullPointerException] { new PathFunSpec { it("hi", null) {} } } val caught = intercept[NullPointerException] { new PathFunSpec { it("hi", mytags.SlowAsMolasses, null) {} } } assert(caught.getMessage === "a test tag was null") intercept[NullPointerException] { new PathFunSpec { it("hi", mytags.SlowAsMolasses, null, mytags.WeakAsAKitten) {} } } // ignore intercept[NullPointerException] { new PathFunSpec { ignore("hi", null) {} } } val caught2 = intercept[NullPointerException] { new PathFunSpec { ignore("hi", mytags.SlowAsMolasses, null) {} } } assert(caught2.getMessage === "a test tag was null") intercept[NullPointerException] { new PathFunSpec { ignore("hi", mytags.SlowAsMolasses, null, mytags.WeakAsAKitten) {} } } } case class TestWasCalledCounts(var theTestThisCalled: Boolean, var theTestThatCalled: Boolean) class TestWasCalledSuite(val counts: TestWasCalledCounts) extends PathFunSpec { def this() { this(TestWasCalledCounts(false, false)) } it("should run this") { counts.theTestThisCalled = true } it("should run that, maybe") { counts.theTestThatCalled = true } override def newInstance = new TestWasCalledSuite(counts) } "should execute all tests when run is called with testName None" in { val b = new TestWasCalledSuite b.run(None, Args(SilentReporter)) assert(b.counts.theTestThisCalled) assert(b.counts.theTestThatCalled) } "should execute one test when run is called with a defined testName" in { val a = new TestWasCalledSuite val rep = new EventRecordingReporter a.run(Some("should run this"), Args(rep)) assert(a.counts.theTestThisCalled) assert(a.counts.theTestThatCalled) // In a path trait, this gets executed, but not reported val tse = rep.testSucceededEventsReceived assert(tse.size == 1) assert(tse(0).testName === "should run this") val tfe = rep.testFailedEventsReceived assert(tfe.size === 0) val tste = rep.testStartingEventsReceived assert(tste.size === 1) } "should report as ignored, and not run, tests marked ignored" in { class AFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { it("test this") { counts.theTestThisCalled = true } it("test that") { counts.theTestThatCalled = true } override def newInstance = new AFunSpec(counts) } val a = new AFunSpec(TestWasCalledCounts(false, false)) val repA = new TestIgnoredTrackingReporter a.run(None, Args(repA)) assert(!repA.testIgnoredReceived) assert(a.counts.theTestThisCalled) assert(a.counts.theTestThatCalled) class BFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { ignore("test this") { counts.theTestThisCalled = true } it("test that") { counts.theTestThatCalled = true } override def newInstance = new BFunSpec(counts) } val b = new BFunSpec(TestWasCalledCounts(false, false)) val repB = new TestIgnoredTrackingReporter b.run(None, Args(repB)) assert(repB.testIgnoredReceived) assert(repB.lastEvent.isDefined) assert(repB.lastEvent.get.testName endsWith "test this") assert(!b.counts.theTestThisCalled) assert(b.counts.theTestThatCalled) class CFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { it("test this") { counts.theTestThisCalled = true } ignore("test that") { counts.theTestThatCalled = true } override def newInstance = new CFunSpec(counts) } val c = new CFunSpec(TestWasCalledCounts(false, false)) val repC = new TestIgnoredTrackingReporter c.run(None, Args(repC)) assert(repC.testIgnoredReceived) assert(repC.lastEvent.isDefined) assert(repC.lastEvent.get.testName endsWith "test that", repC.lastEvent.get.testName) assert(c.counts.theTestThisCalled) assert(!c.counts.theTestThatCalled) // The order I want is order of appearance in the file. // Will try and implement that tomorrow. Subtypes will be able to change the order. class DFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { ignore("test this") { counts.theTestThisCalled = true } ignore("test that") { counts.theTestThatCalled = true } override def newInstance = new DFunSpec(counts) } val d = new DFunSpec(TestWasCalledCounts(false, false)) val repD = new TestIgnoredTrackingReporter d.run(None, Args(repD)) assert(repD.testIgnoredReceived) assert(repD.lastEvent.isDefined) assert(repD.lastEvent.get.testName endsWith "test that") // last because should be in order of appearance assert(!d.counts.theTestThisCalled) assert(!d.counts.theTestThatCalled) } "should ignore a test marked as ignored if run is invoked with that testName" in { // If I provide a specific testName to run, then it should ignore an Ignore on that test // method and actually invoke it. class EFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { def this() { this(TestWasCalledCounts(false, false)) } ignore("test this") { counts.theTestThisCalled = true } it("test that") { counts.theTestThatCalled = true } override def newInstance = new EFunSpec(counts) } val e = new EFunSpec val repE = new EventRecordingReporter e.run(Some("test this"), Args(repE)) assert(repE.testIgnoredEventsReceived.size === 1) assert(!e.counts.theTestThisCalled) assert(e.counts.theTestThatCalled) // In a path trait, tests other than the Some(testName) get executed, but not reported val tste = repE.testStartingEventsReceived assert(tste.size === 0) } "should run only those tests selected by the tags to include and exclude sets" in { // Nothing is excluded class AFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { it("test this", mytags.SlowAsMolasses) { counts.theTestThisCalled = true } it("test that") { counts.theTestThatCalled = true } override def newInstance = new AFunSpec(counts) } val a = new AFunSpec(TestWasCalledCounts(false, false)) val repA = new TestIgnoredTrackingReporter a.run(None, Args(repA)) assert(!repA.testIgnoredReceived) assert(a.counts.theTestThisCalled) assert(a.counts.theTestThatCalled) // SlowAsMolasses is included, one test should be excluded class BFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { it("test this", mytags.SlowAsMolasses) { counts.theTestThisCalled = true } it("test that") { counts.theTestThatCalled = true } override def newInstance = new BFunSpec(counts) } val b = new BFunSpec(TestWasCalledCounts(false, false)) val repB = new EventRecordingReporter b.run(None, Args(repB, Stopper.default, Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set()), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repB.testIgnoredEventsReceived.isEmpty) assert(b.counts.theTestThisCalled) assert(b.counts.theTestThatCalled) assert(repB.testStartingEventsReceived.size === 1) assert(repB.testStartingEventsReceived(0).testName == "test this") // SlowAsMolasses is included, and both tests should be included class CFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { it("test this", mytags.SlowAsMolasses) { counts.theTestThisCalled = true } it("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } override def newInstance = new CFunSpec(counts) } val c = new CFunSpec(TestWasCalledCounts(false, false)) val repC = new EventRecordingReporter c.run(None, Args(repC, Stopper.default, Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set()), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repC.testIgnoredEventsReceived.isEmpty) assert(c.counts.theTestThisCalled) assert(c.counts.theTestThatCalled) assert(repC.testStartingEventsReceived.size === 2) // SlowAsMolasses is included. both tests should be included but one ignored class DFunSpec(val counts: TestWasCalledCounts) extends PathFunSpec { ignore("test this", mytags.SlowAsMolasses) { counts.theTestThisCalled = true } it("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } override def newInstance = new DFunSpec(counts) } val d = new DFunSpec(TestWasCalledCounts(false, false)) val repD = new EventRecordingReporter d.run(None, Args(repD, Stopper.default, Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set("org.scalatest.Ignore")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repD.testIgnoredEventsReceived.size === 1) assert(!d.counts.theTestThisCalled) assert(d.counts.theTestThatCalled) assert(repD.testStartingEventsReceived.size === 1) assert(repD.testStartingEventsReceived(0).testName === "test that") case class ThreeCounts(var theTestThisCalled: Boolean, var theTestThatCalled: Boolean, var theTestTheOtherCalled: Boolean) // SlowAsMolasses included, FastAsLight excluded class EFunSpec(val counts: ThreeCounts) extends PathFunSpec { it("test this", mytags.SlowAsMolasses, mytags.FastAsLight) { counts.theTestThisCalled = true } it("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } it("test the other") { counts.theTestTheOtherCalled = true } override def newInstance = new EFunSpec(counts) } val e = new EFunSpec(ThreeCounts(false, false, false)) val repE = new EventRecordingReporter e.run(None, Args(repE, Stopper.default, Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set("org.scalatest.FastAsLight")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repE.testIgnoredEventsReceived.isEmpty) assert(e.counts.theTestThisCalled) assert(e.counts.theTestThatCalled) assert(e.counts.theTestTheOtherCalled) assert(repE.testStartingEventsReceived.size === 1) assert(repE.testStartingEventsReceived(0).testName === "test that") // An Ignored test that was both included and excluded should not generate a TestIgnored event class FFunSpec(val counts: ThreeCounts) extends PathFunSpec { ignore("test this", mytags.SlowAsMolasses, mytags.FastAsLight) { counts.theTestThisCalled = true } it("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } it("test the other") { counts.theTestTheOtherCalled = true } override def newInstance = new FFunSpec(counts) } val f = new FFunSpec(ThreeCounts(false, false, false)) val repF = new EventRecordingReporter f.run(None, Args(repF, Stopper.default, Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set("org.scalatest.FastAsLight")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repF.testIgnoredEventsReceived.isEmpty) assert(!f.counts.theTestThisCalled) assert(f.counts.theTestThatCalled) assert(f.counts.theTestTheOtherCalled) assert(repE.testStartingEventsReceived.size === 1) assert(repE.testStartingEventsReceived(0).testName === "test that") // An Ignored test that was not included should not generate a TestIgnored event class GFunSpec(val counts: ThreeCounts) extends PathFunSpec { it("test this", mytags.SlowAsMolasses, mytags.FastAsLight) { counts.theTestThisCalled = true } it("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } ignore("test the other") { counts.theTestTheOtherCalled = true } override def newInstance = new GFunSpec(counts) } val g = new GFunSpec(ThreeCounts(false, false, false)) val repG = new EventRecordingReporter g.run(None, Args(repG, Stopper.default, Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set("org.scalatest.FastAsLight")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repG.testIgnoredEventsReceived.isEmpty) assert(g.counts.theTestThisCalled) assert(g.counts.theTestThatCalled) assert(!g.counts.theTestTheOtherCalled) assert(repG.testStartingEventsReceived.size === 1) assert(repG.testStartingEventsReceived(0).testName === "test that") // No tagsToInclude set, FastAsLight excluded class HFunSpec(val counts: ThreeCounts) extends PathFunSpec { it("test this", mytags.SlowAsMolasses, mytags.FastAsLight) { counts.theTestThisCalled = true } it("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } it("test the other") { counts.theTestTheOtherCalled = true } override def newInstance = new HFunSpec(counts) } val h = new HFunSpec(ThreeCounts(false, false, false)) val repH = new EventRecordingReporter h.run(None, Args(repH, Stopper.default, Filter(None, Set("org.scalatest.FastAsLight")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repH.testIgnoredEventsReceived.isEmpty) assert(h.counts.theTestThisCalled) assert(h.counts.theTestThatCalled) assert(h.counts.theTestTheOtherCalled) assert(repH.testStartingEventsReceived.size === 2) assert(repH.testStartingEventsReceived.exists(_.testName == "test that")) assert(repH.testStartingEventsReceived.exists(_.testName == "test the other")) // No tagsToInclude set, mytags.SlowAsMolasses excluded class IFunSpec(val counts: ThreeCounts) extends PathFunSpec { it("test this", mytags.SlowAsMolasses, mytags.FastAsLight) { counts.theTestThisCalled = true } it("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } it("test the other") { counts.theTestTheOtherCalled = true } override def newInstance = new IFunSpec(counts) } val i = new IFunSpec(ThreeCounts(false, false, false)) val repI = new EventRecordingReporter i.run(None, Args(repI, Stopper.default, Filter(None, Set("org.scalatest.SlowAsMolasses")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repI.testIgnoredEventsReceived.isEmpty) assert(i.counts.theTestThisCalled) assert(i.counts.theTestThatCalled) assert(i.counts.theTestTheOtherCalled) assert(repI.testStartingEventsReceived.size === 1) assert(repI.testStartingEventsReceived(0).testName === "test the other") // No tagsToInclude set, mytags.SlowAsMolasses excluded, TestIgnored should not be received on excluded ones class JFunSpec(val counts: ThreeCounts) extends PathFunSpec { ignore("test this", mytags.SlowAsMolasses, mytags.FastAsLight) { counts.theTestThisCalled = true } ignore("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } it("test the other") { counts.theTestTheOtherCalled = true } override def newInstance = new JFunSpec(counts) } val j = new JFunSpec(ThreeCounts(false, false, false)) val repJ = new TestIgnoredTrackingReporter j.run(None, Args(repJ, Stopper.default, Filter(None, Set("org.scalatest.SlowAsMolasses")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(!repJ.testIgnoredReceived) assert(!j.counts.theTestThisCalled) assert(!j.counts.theTestThatCalled) assert(j.counts.theTestTheOtherCalled) // Same as previous, except Ignore specifically mentioned in excludes set class KFunSpec(val counts: ThreeCounts) extends PathFunSpec { ignore("test this", mytags.SlowAsMolasses, mytags.FastAsLight) { counts.theTestThisCalled = true } ignore("test that", mytags.SlowAsMolasses) { counts.theTestThatCalled = true } ignore("test the other") { counts.theTestTheOtherCalled = true } override def newInstance = new KFunSpec(counts) } val k = new KFunSpec(ThreeCounts(false, false, false)) val repK = new TestIgnoredTrackingReporter k.run(None, Args(repK, Stopper.default, Filter(None, Set("org.scalatest.SlowAsMolasses", "org.scalatest.Ignore")), ConfigMap.empty, None, new Tracker, Set.empty)) assert(repK.testIgnoredReceived) assert(!k.counts.theTestThisCalled) assert(!k.counts.theTestThatCalled) assert(!k.counts.theTestTheOtherCalled) } "should return the correct test count from its expectedTestCount method" in { class AFunSpec extends PathFunSpec { it("test this") {} it("test that") {} override def newInstance = new AFunSpec } val a = new AFunSpec assert(a.expectedTestCount(Filter()) === 2) class BFunSpec extends PathFunSpec { ignore("test this") {} it("test that") {} override def newInstance = new BFunSpec } val b = new BFunSpec assert(b.expectedTestCount(Filter()) === 1) class CFunSpec extends PathFunSpec { it("test this", mytags.FastAsLight) {} it("test that") {} override def newInstance = new CFunSpec } val c = new CFunSpec assert(c.expectedTestCount(Filter(Some(Set("org.scalatest.FastAsLight")), Set())) === 1) assert(c.expectedTestCount(Filter(None, Set("org.scalatest.FastAsLight"))) === 1) class DFunSpec extends PathFunSpec { it("test this", mytags.FastAsLight, mytags.SlowAsMolasses) {} it("test that", mytags.SlowAsMolasses) {} it("test the other thing") {} override def newInstance = new DFunSpec } val d = new DFunSpec assert(d.expectedTestCount(Filter(Some(Set("org.scalatest.FastAsLight")), Set())) === 1) assert(d.expectedTestCount(Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set("org.scalatest.FastAsLight"))) === 1) assert(d.expectedTestCount(Filter(None, Set("org.scalatest.SlowAsMolasses"))) === 1) assert(d.expectedTestCount(Filter()) === 3) class EFunSpec extends PathFunSpec { it("test this", mytags.FastAsLight, mytags.SlowAsMolasses) {} it("test that", mytags.SlowAsMolasses) {} ignore("test the other thing") {} // ignore("test the other thing") {} override def newInstance = new EFunSpec } val e = new EFunSpec assert(e.expectedTestCount(Filter(Some(Set("org.scalatest.FastAsLight")), Set())) === 1) assert(e.expectedTestCount(Filter(Some(Set("org.scalatest.SlowAsMolasses")), Set("org.scalatest.FastAsLight"))) === 1) assert(e.expectedTestCount(Filter(None, Set("org.scalatest.SlowAsMolasses"))) === 0) assert(e.expectedTestCount(Filter()) === 2) val f = new Suites(a, b, c, d, e) assert(f.expectedTestCount(Filter()) === 10) } "should generate a TestPending message when the test body is (pending)" in { class AFunSpec extends PathFunSpec { it("should do this") (pending) it("should do that") { assert(2 + 2 === 4) } it("should do something else") { assert(2 + 2 === 4) pending } override def newInstance = new AFunSpec } val a = new AFunSpec val rep = new EventRecordingReporter a.run(None, Args(rep)) val tp = rep.testPendingEventsReceived assert(tp.size === 2) } "should generate a test failure if a Throwable, or an Error other than direct Error subtypes known in JDK 1.5, excluding AssertionError" in { class AFunSpec extends PathFunSpec { it("throws AssertionError") { throw new AssertionError } it("throws plain old Error") { throw new Error } it("throws Throwable") { throw new Throwable } override def newInstance = new AFunSpec } val a = new AFunSpec val rep = new EventRecordingReporter a.run(None, Args(rep)) val tf = rep.testFailedEventsReceived assert(tf.size === 3) } "should propagate out Errors that are direct subtypes of Error in JDK 1.5, other than AssertionError, causing Suites and Runs to abort." in { class AFunSpec extends PathFunSpec { it("throws AssertionError") { throw new OutOfMemoryError } override def newInstance = new AFunSpec } // val a = new AFunSpec intercept[OutOfMemoryError] { new AFunSpec // a.run(None, Args(SilentReporter)) } } /* "should send InfoProvided events with aboutAPendingTest set to true for info calls made from a test that is pending" in { class AFunSpec extends PathFunSpec with GivenWhenThen { it("should do something else") { given("two integers") when("one is subracted from the other") then("the result is the difference between the two numbers") pending } override def newInstance = new AFunSpec } val a = new AFunSpec val rep = new EventRecordingReporter a.run(None, Args(rep)) val testPending = rep.testPendingEventsReceived assert(testPending.size === 1) val recordedEvents = testPending(0).recordedEvents assert(recordedEvents.size === 3) for (event <- recordedEvents) { val ip = event.asInstanceOf[InfoProvided] assert(ip.aboutAPendingTest.isDefined && ip.aboutAPendingTest.get) } } "should send InfoProvided events with aboutAPendingTest set to false for info calls made from a test that is not pending" in { class AFunSpec extends PathFunSpec with GivenWhenThen { it("should do something else") { given("two integers") when("one is subracted from the other") then("the result is the difference between the two numbers") assert(1 + 1 === 2) } override def newInstance = new AFunSpec } val a = new AFunSpec val rep = new EventRecordingReporter a.run(None, Args(rep)) val testSucceeded = rep.testSucceededEventsReceived assert(testSucceeded.size === 1) val recordedEvents = testSucceeded(0).recordedEvents assert(recordedEvents.size === 3) for (event <- recordedEvents) { val ip = event.asInstanceOf[InfoProvided] assert(ip.aboutAPendingTest.isDefined && !ip.aboutAPendingTest.get) } } */ } "when failure happens" - { "should fire TestFailed event with correct stack depth info when test failed" in { class TestSpec extends FunSpec { it("fail scenario") { assert(1 === 2) } describe("a feature") { it("nested fail scenario") { assert(1 === 2) } } override def newInstance = new TestSpec } val rep = new EventRecordingReporter val s1 = new TestSpec s1.run(None, Args(rep)) assert(rep.testFailedEventsReceived.size === 2) assert(rep.testFailedEventsReceived(0).throwable.get.asInstanceOf[TestFailedException].failedCodeFileName.get === "FunSpecSpec.scala") assert(rep.testFailedEventsReceived(0).throwable.get.asInstanceOf[TestFailedException].failedCodeLineNumber.get === thisLineNumber - 14) assert(rep.testFailedEventsReceived(1).throwable.get.asInstanceOf[TestFailedException].failedCodeFileName.get === "FunSpecSpec.scala") assert(rep.testFailedEventsReceived(1).throwable.get.asInstanceOf[TestFailedException].failedCodeLineNumber.get === thisLineNumber - 12) } "should generate TestRegistrationClosedException with correct stack depth info when has a it nested inside a it" in { class TestSpec extends FunSpec { describe("a feature") { it("a scenario") { it("nested scenario") { assert(1 === 2) } } } override def newInstance = new TestSpec } val rep = new EventRecordingReporter val s = new TestSpec s.run(None, Args(rep)) val testFailedEvents = rep.testFailedEventsReceived assert(testFailedEvents.size === 1) assert(testFailedEvents(0).throwable.get.getClass() === classOf[TestRegistrationClosedException]) val trce = testFailedEvents(0).throwable.get.asInstanceOf[TestRegistrationClosedException] assert("FunSpecSpec.scala" === trce.failedCodeFileName.get) assert(trce.failedCodeLineNumber.get === thisLineNumber - 15) assert(trce.message == Some("An it clause may not appear inside another it or they clause.")) } "should generate TestRegistrationClosedException with correct stack depth info when has a ignore nested inside a it" in { class TestSpec extends FunSpec { describe("a feature") { it("a scenario") { ignore("nested scenario") { assert(1 === 2) } } } override def newInstance = new TestSpec } val rep = new EventRecordingReporter val s = new TestSpec s.run(None, Args(rep)) val testFailedEvents = rep.testFailedEventsReceived assert(testFailedEvents.size === 1) assert(testFailedEvents(0).throwable.get.getClass() === classOf[TestRegistrationClosedException]) val trce = testFailedEvents(0).throwable.get.asInstanceOf[TestRegistrationClosedException] assert("FunSpecSpec.scala" === trce.failedCodeFileName.get) assert(trce.failedCodeLineNumber.get === thisLineNumber - 15) assert(trce.message == Some("An ignore clause may not appear inside an it or a they clause.")) } "should generate TestRegistrationClosedException with correct stack depth info when has a they nested inside a they" in { class TestSpec extends FunSpec { describe("a feature") { they("a scenario") { they("nested scenario") { assert(1 === 2) } } } override def newInstance = new TestSpec } val rep = new EventRecordingReporter val s = new TestSpec s.run(None, Args(rep)) val testFailedEvents = rep.testFailedEventsReceived assert(testFailedEvents.size === 1) assert(testFailedEvents(0).throwable.get.getClass() === classOf[TestRegistrationClosedException]) val trce = testFailedEvents(0).throwable.get.asInstanceOf[TestRegistrationClosedException] assert("FunSpecSpec.scala" === trce.failedCodeFileName.get) assert(trce.failedCodeLineNumber.get === thisLineNumber - 15) assert(trce.message == Some("A they clause may not appear inside another it or they clause.")) } "should generate TestRegistrationClosedException with correct stack depth info when has a ignore nested inside a they" in { class TestSpec extends FunSpec { describe("a feature") { they("a scenario") { ignore("nested scenario") { assert(1 === 2) } } } override def newInstance = new TestSpec } val rep = new EventRecordingReporter val s = new TestSpec s.run(None, Args(rep)) val testFailedEvents = rep.testFailedEventsReceived assert(testFailedEvents.size === 1) assert(testFailedEvents(0).throwable.get.getClass() === classOf[TestRegistrationClosedException]) val trce = testFailedEvents(0).throwable.get.asInstanceOf[TestRegistrationClosedException] assert("FunSpecSpec.scala" === trce.failedCodeFileName.get) assert(trce.failedCodeLineNumber.get === thisLineNumber - 15) assert(trce.message == Some("An ignore clause may not appear inside an it or a they clause.")) } "should generate NotAllowedException wrapping a TestFailedException when assert fails in scope" in { class TestSpec extends FunSpec { describe("a feature") { val a = 1 assert(a == 2) } } val e = intercept[NotAllowedException] { new TestSpec } assert("FunSpecSpec.scala" == e.failedCodeFileName.get) assert(e.failedCodeLineNumber.get == thisLineNumber - 3) assert(e.message == Some(FailureMessages.assertionShouldBePutInsideItOrTheyClauseNotDescribeClause)) assert(e.cause.isDefined) val causeThrowable = e.cause.get assert(causeThrowable.isInstanceOf[TestFailedException]) val cause = causeThrowable.asInstanceOf[TestFailedException] assert("FunSpecSpec.scala" == cause.failedCodeFileName.get) assert(cause.failedCodeLineNumber.get == thisLineNumber - 15) assert(cause.message == Some(FailureMessages.didNotEqual(1, 2))) } "should generate NotAllowedException wrapping a TestCanceledException when assume fails in scope" in { class TestSpec extends FunSpec { describe("a feature") { val a = 1 assume(a == 2) } } val e = intercept[NotAllowedException] { new TestSpec } assert("FunSpecSpec.scala" == e.failedCodeFileName.get) assert(e.failedCodeLineNumber.get == thisLineNumber - 3) assert(e.message == Some(FailureMessages.assertionShouldBePutInsideItOrTheyClauseNotDescribeClause)) assert(e.cause.isDefined) val causeThrowable = e.cause.get assert(causeThrowable.isInstanceOf[TestCanceledException]) val cause = causeThrowable.asInstanceOf[TestCanceledException] assert("FunSpecSpec.scala" == cause.failedCodeFileName.get) assert(cause.failedCodeLineNumber.get == thisLineNumber - 15) assert(cause.message == Some(FailureMessages.didNotEqual(1, 2))) } "should generate NotAllowedException wrapping a non-fatal RuntimeException is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new RuntimeException("on purpose") } } val e = intercept[NotAllowedException] { new TestSpec } assert("FunSpecSpec.scala" == e.failedCodeFileName.get) assert(e.failedCodeLineNumber.get == thisLineNumber - 3) assert(e.cause.isDefined) val causeThrowable = e.cause.get assert(e.message == Some(FailureMessages.exceptionWasThrownInDescribeClause(UnquotedString(causeThrowable.getClass.getName), "a feature"))) assert(causeThrowable.isInstanceOf[RuntimeException]) val cause = causeThrowable.asInstanceOf[RuntimeException] assert(cause.getMessage == "on purpose") } "should propagate AnnotationFormatError when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new AnnotationFormatError("on purpose") } } val e = intercept[AnnotationFormatError] { new TestSpec } assert(e.getMessage == "on purpose") } "should propagate AWTError when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new AWTError("on purpose") } } val e = intercept[AWTError] { new TestSpec } assert(e.getMessage == "on purpose") } "should propagate CoderMalfunctionError when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new CoderMalfunctionError(new RuntimeException("on purpose")) } } val e = intercept[CoderMalfunctionError] { new TestSpec } assert(e.getMessage == "java.lang.RuntimeException: on purpose") } "should propagate FactoryConfigurationError when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new FactoryConfigurationError("on purpose") } } val e = intercept[FactoryConfigurationError] { new TestSpec } assert(e.getMessage == "on purpose") } "should propagate LinkageError when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new LinkageError("on purpose") } } val e = intercept[LinkageError] { new TestSpec } assert(e.getMessage == "on purpose") } "should propagate ThreadDeath when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new ThreadDeath } } val e = intercept[ThreadDeath] { new TestSpec } assert(e.getMessage == null) } "should propagate TransformerFactoryConfigurationError when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new TransformerFactoryConfigurationError("on purpose") } } val e = intercept[TransformerFactoryConfigurationError] { new TestSpec } assert(e.getMessage == "on purpose") } "should propagate VirtualMachineError when it is thrown inside scope" in { class TestSpec extends FunSpec { describe("a feature") { throw new VirtualMachineError("on purpose") {} } } val e = intercept[VirtualMachineError] { new TestSpec } assert(e.getMessage == "on purpose") } } }
SRGOM/scalatest
scalatest-test/src/test/scala/org/scalatest/path/FunSpecSpec.scala
Scala
apache-2.0
45,423
// Generated by <a href="http://scalaxb.org/">scalaxb</a>. package xmlschema import masked.scalaxb /** Part 1 version: Id: structures.xsd,v 1.2 2004/01/15 11:34:25 ht Exp Part 2 version: Id: datatypes.xsd,v 1.3 2004/01/23 18:11:13 ht Exp */ /** This type is extended by almost all schema types to allow attributes from other namespaces to be added to user schemas. */ trait XOpenAttrsable { val attributes: Map[String, scalaxb.DataRecord[Any]] } /** This type is extended by almost all schema types to allow attributes from other namespaces to be added to user schemas. */ case class XOpenAttrs(attributes: Map[String, scalaxb.DataRecord[Any]]) extends XOpenAttrsable /** This type is extended by all types which allow annotation other than <schema> itself */ trait XAnnotatedable extends XOpenAttrsable { val annotation: Option[xmlschema.XAnnotation] val id: Option[String] val attributes: Map[String, scalaxb.DataRecord[Any]] } /** This type is extended by all types which allow annotation other than <schema> itself */ case class XAnnotated(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable trait XFormChoice object XFormChoice { def fromString(value: String, scope: scala.xml.NamespaceBinding): XFormChoice = value match { case "qualified" => XQualified case "unqualified" => XUnqualified } } case object XQualified extends XFormChoice { override def toString = "qualified" } case object XUnqualified extends XFormChoice { override def toString = "unqualified" } trait XReducedDerivationControl object XReducedDerivationControl { def fromString(value: String, scope: scala.xml.NamespaceBinding): XReducedDerivationControl = value match { case "extension" => XExtensionValue2 case "restriction" => XRestrictionValue3 } } case object XExtensionValue2 extends XReducedDerivationControl { override def toString = "extension" } case object XRestrictionValue3 extends XReducedDerivationControl { override def toString = "restriction" } trait XTypeDerivationControl object XTypeDerivationControl { def fromString(value: String, scope: scala.xml.NamespaceBinding): XTypeDerivationControl = value match { case "extension" => XExtensionValue case "restriction" => XRestrictionValue2 case "list" => XListValue2 case "union" => XUnionValue2 } } case object XExtensionValue extends XTypeDerivationControl { override def toString = "extension" } case object XRestrictionValue2 extends XTypeDerivationControl { override def toString = "restriction" } case object XListValue2 extends XTypeDerivationControl { override def toString = "list" } case object XUnionValue2 extends XTypeDerivationControl { override def toString = "union" } case class XSchema(xschemaoption: Seq[scalaxb.DataRecord[xmlschema.XSchemaOption]] = Nil, xschemasequence1: Seq[xmlschema.XSchemaSequence1] = Nil, targetNamespace: Option[java.net.URI] = None, version: Option[String] = None, finalDefault: String, blockDefault: String, attributeFormDefault: xmlschema.XFormChoice, elementFormDefault: xmlschema.XFormChoice, id: Option[String] = None, xmllang: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XOpenAttrsable trait XSchemaOption case class XSchemaSequence1(xSchemaTopOption1: scalaxb.DataRecord[Any], annotation: Seq[xmlschema.XAnnotation] = Nil) trait XUse object XUse { def fromString(value: String, scope: scala.xml.NamespaceBinding): XUse = value match { case "prohibited" => XProhibited case "optional" => XOptional case "required" => XRequired } } case object XProhibited extends XUse { override def toString = "prohibited" } case object XOptional extends XUse { override def toString = "optional" } case object XRequired extends XUse { override def toString = "required" } trait XAttributable extends XAnnotatedable with XAttrDeclsOption1 { val annotation: Option[xmlschema.XAnnotation] val simpleType: Option[xmlschema.XLocalSimpleType] val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val typeValue: Option[javax.xml.namespace.QName] val use: xmlschema.XUse val default: Option[String] val fixed: Option[String] val form: Option[xmlschema.XFormChoice] val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XAttribute(annotation: Option[xmlschema.XAnnotation] = None, simpleType: Option[xmlschema.XLocalSimpleType] = None, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, typeValue: Option[javax.xml.namespace.QName] = None, use: xmlschema.XUse, default: Option[String] = None, fixed: Option[String] = None, form: Option[xmlschema.XFormChoice] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAttributable case class XTopLevelAttribute(annotation: Option[xmlschema.XAnnotation] = None, simpleType: Option[xmlschema.XLocalSimpleType] = None, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, typeValue: Option[javax.xml.namespace.QName] = None, use: xmlschema.XUse, default: Option[String] = None, fixed: Option[String] = None, form: Option[xmlschema.XFormChoice] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAttributable with XSchemaTopOption trait XComplexType extends XAnnotatedable { val annotation: Option[xmlschema.XAnnotation] val xComplexTypeModelOption3: scalaxb.DataRecord[xmlschema.XComplexTypeModelOption] val id: Option[String] val name: Option[String] val mixed: Boolean val abstractValue: Boolean val finalValue: Option[String] val block: Option[String] val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XTopLevelComplexType(annotation: Option[xmlschema.XAnnotation] = None, xComplexTypeModelOption3: scalaxb.DataRecord[xmlschema.XComplexTypeModelOption], id: Option[String] = None, name: Option[String] = None, mixed: Boolean, abstractValue: Boolean, finalValue: Option[String] = None, block: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XComplexType with XRedefinableOption case class XLocalComplexType(annotation: Option[xmlschema.XAnnotation] = None, xComplexTypeModelOption3: scalaxb.DataRecord[xmlschema.XComplexTypeModelOption], id: Option[String] = None, name: Option[String] = None, mixed: Boolean, abstractValue: Boolean, finalValue: Option[String] = None, block: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XComplexType with XElementOption with XTopLevelElementOption with XLocalElementableOption with XNarrowMaxMinOption trait XRestrictionTypable extends XAnnotatedable { val annotation: Option[xmlschema.XAnnotation] val xrestrictiontypableoption: Option[scalaxb.DataRecord[Any]] val xAttrDeclsSequence4: xmlschema.XAttrDeclsSequence val id: Option[String] val base: javax.xml.namespace.QName val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XRestrictionType(annotation: Option[xmlschema.XAnnotation] = None, xrestrictiontypableoption: Option[scalaxb.DataRecord[Any]] = None, xAttrDeclsSequence4: xmlschema.XAttrDeclsSequence, id: Option[String] = None, base: javax.xml.namespace.QName, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XRestrictionTypable trait XRestrictionTypableOption case class XComplexRestrictionType(annotation: Option[xmlschema.XAnnotation] = None, xrestrictiontypableoption: Option[scalaxb.DataRecord[Any]] = None, xAttrDeclsSequence4: xmlschema.XAttrDeclsSequence, id: Option[String] = None, base: javax.xml.namespace.QName, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XRestrictionTypable with XComplexContentOption trait XComplexRestrictionTypeOption trait XExtensionTypable extends XAnnotatedable with XComplexContentOption { val annotation: Option[xmlschema.XAnnotation] val xTypeDefParticleOption3: Option[scalaxb.DataRecord[xmlschema.XTypeDefParticleOption]] val xAttrDeclsSequence4: xmlschema.XAttrDeclsSequence val id: Option[String] val base: javax.xml.namespace.QName val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XExtensionType(annotation: Option[xmlschema.XAnnotation] = None, xTypeDefParticleOption3: Option[scalaxb.DataRecord[xmlschema.XTypeDefParticleOption]] = None, xAttrDeclsSequence4: xmlschema.XAttrDeclsSequence, id: Option[String] = None, base: javax.xml.namespace.QName, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XExtensionTypable case class XComplexContent(annotation: Option[xmlschema.XAnnotation] = None, xcomplexcontentoption: scalaxb.DataRecord[xmlschema.XComplexContentOption], id: Option[String] = None, mixed: Option[Boolean] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XComplexTypeModelOption trait XComplexContentOption case class XSimpleRestrictionType(annotation: Option[xmlschema.XAnnotation] = None, xrestrictiontypableoption: Option[scalaxb.DataRecord[Any]] = None, xAttrDeclsSequence4: xmlschema.XAttrDeclsSequence, id: Option[String] = None, base: javax.xml.namespace.QName, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XRestrictionTypable with XSimpleContentOption trait XSimpleRestrictionTypeOption case class XSimpleExtensionType(annotation: Option[xmlschema.XAnnotation] = None, xTypeDefParticleOption3: Option[scalaxb.DataRecord[xmlschema.XTypeDefParticleOption]] = None, xAttrDeclsSequence4: xmlschema.XAttrDeclsSequence, id: Option[String] = None, base: javax.xml.namespace.QName, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XExtensionTypable with XSimpleContentOption case class XSimpleContent(annotation: Option[xmlschema.XAnnotation] = None, xsimplecontentoption: scalaxb.DataRecord[xmlschema.XSimpleContentOption], id: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XComplexTypeModelOption trait XSimpleContentOption /** The element element can be used either at the top level to define an element-type binding globally, or within a content model to either reference a globally-defined element or type or declare an element-type binding locally. The ref form is not allowed at the top level. */ trait XElement extends XAnnotatedable { val annotation: Option[xmlschema.XAnnotation] val xelementoption: Option[scalaxb.DataRecord[xmlschema.XElementOption]] val xIdentityConstraintOption4: Seq[scalaxb.DataRecord[xmlschema.XIdentityConstraintOption]] val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val typeValue: Option[javax.xml.namespace.QName] val substitutionGroup: Option[javax.xml.namespace.QName] val minOccurs: BigInt val maxOccurs: String val default: Option[String] val fixed: Option[String] val nillable: Boolean val abstractValue: Boolean val finalValue: Option[String] val block: Option[String] val form: Option[xmlschema.XFormChoice] val attributes: Map[String, scalaxb.DataRecord[Any]] } trait XElementOption case class XTopLevelElement(annotation: Option[xmlschema.XAnnotation] = None, xelementoption: Option[scalaxb.DataRecord[xmlschema.XElementOption]] = None, xIdentityConstraintOption4: Seq[scalaxb.DataRecord[xmlschema.XIdentityConstraintOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, typeValue: Option[javax.xml.namespace.QName] = None, substitutionGroup: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, default: Option[String] = None, fixed: Option[String] = None, nillable: Boolean, abstractValue: Boolean, finalValue: Option[String] = None, block: Option[String] = None, form: Option[xmlschema.XFormChoice] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XElement with XSchemaTopOption trait XTopLevelElementOption trait XLocalElementable extends XElement with XNestedParticleOption with XParticleOption { val annotation: Option[xmlschema.XAnnotation] val xelementoption: Option[scalaxb.DataRecord[xmlschema.XElementOption]] val xIdentityConstraintOption4: Seq[scalaxb.DataRecord[xmlschema.XIdentityConstraintOption]] val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val typeValue: Option[javax.xml.namespace.QName] val substitutionGroup: Option[javax.xml.namespace.QName] val minOccurs: BigInt val maxOccurs: String val default: Option[String] val fixed: Option[String] val nillable: Boolean val abstractValue: Boolean val finalValue: Option[String] val block: Option[String] val form: Option[xmlschema.XFormChoice] val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XLocalElement(annotation: Option[xmlschema.XAnnotation] = None, xelementoption: Option[scalaxb.DataRecord[xmlschema.XElementOption]] = None, xIdentityConstraintOption4: Seq[scalaxb.DataRecord[xmlschema.XIdentityConstraintOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, typeValue: Option[javax.xml.namespace.QName] = None, substitutionGroup: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, default: Option[String] = None, fixed: Option[String] = None, nillable: Boolean, abstractValue: Boolean, finalValue: Option[String] = None, block: Option[String] = None, form: Option[xmlschema.XFormChoice] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XLocalElementable trait XLocalElementableOption /** group type for explicit groups, named top-level groups and group references */ trait XGroup extends XAnnotatedable { val annotation: Option[xmlschema.XAnnotation] val xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val minOccurs: BigInt val maxOccurs: String val attributes: Map[String, scalaxb.DataRecord[Any]] } trait XRealGroupable extends XGroup { val annotation: Option[xmlschema.XAnnotation] val xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val minOccurs: BigInt val maxOccurs: String val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XRealGroup(annotation: Option[xmlschema.XAnnotation] = None, xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XRealGroupable trait XRealGroupableOption case class XAll(annotation: Option[xmlschema.XAnnotation] = None, xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAllable with XNamedGroupOption case class XNamedGroup(annotation: Option[xmlschema.XAnnotation] = None, xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XRealGroupable with XRedefinableOption trait XNamedGroupOption case class XGroupRef(annotation: Option[xmlschema.XAnnotation] = None, xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XRealGroupable with XTypeDefParticleOption with XNestedParticleOption with XParticleOption /** group type for the three kinds of group */ trait XExplicitGroupable extends XGroup with XTypeDefParticleOption with XNestedParticleOption with XParticleOption with XRealGroupableOption { val annotation: Option[xmlschema.XAnnotation] val xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val minOccurs: BigInt val maxOccurs: String val attributes: Map[String, scalaxb.DataRecord[Any]] } /** group type for the three kinds of group */ case class XExplicitGroup(annotation: Option[xmlschema.XAnnotation] = None, xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XExplicitGroupable case class XSimpleExplicitGroup(annotation: Option[xmlschema.XAnnotation] = None, xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XExplicitGroupable with XNamedGroupOption trait XMinOccurs object XMinOccurs { def fromString(value: String, scope: scala.xml.NamespaceBinding): XMinOccurs = value match { case "0" => X0 case "1" => X1 } } case object X0 extends XMinOccurs { override def toString = "0" } case object X1 extends XMinOccurs { override def toString = "1" } trait XMaxOccurs object XMaxOccurs { def fromString(value: String, scope: scala.xml.NamespaceBinding): XMaxOccurs = value match { case "0" => X0Value case "1" => X1Value } } case object X0Value extends XMaxOccurs { override def toString = "0" } case object X1Value extends XMaxOccurs { override def toString = "1" } /** restricted max/min */ case class XNarrowMaxMin(annotation: Option[xmlschema.XAnnotation] = None, xelementoption: Option[scalaxb.DataRecord[xmlschema.XElementOption]] = None, xIdentityConstraintOption4: Seq[scalaxb.DataRecord[xmlschema.XIdentityConstraintOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, typeValue: Option[javax.xml.namespace.QName] = None, substitutionGroup: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, default: Option[String] = None, fixed: Option[String] = None, nillable: Boolean, abstractValue: Boolean, finalValue: Option[String] = None, block: Option[String] = None, form: Option[xmlschema.XFormChoice] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XLocalElementable with XAllModelOption1 trait XNarrowMaxMinOption trait XMinOccursType object XMinOccursType { def fromString(value: String, scope: scala.xml.NamespaceBinding): XMinOccursType = value match { case "0" => X0Value2 case "1" => X1Value2 } } case object X0Value2 extends XMinOccursType { override def toString = "0" } case object X1Value2 extends XMinOccursType { override def toString = "1" } trait XMaxOccursType object XMaxOccursType { def fromString(value: String, scope: scala.xml.NamespaceBinding): XMaxOccursType = value match { case "1" => X1Value3 } } case object X1Value3 extends XMaxOccursType { override def toString = "1" } /** Only elements allowed inside */ trait XAllable extends XExplicitGroupable with XTypeDefParticleOption with XParticleOption with XRealGroupableOption { val annotation: Option[xmlschema.XAnnotation] val xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val minOccurs: BigInt val maxOccurs: String val attributes: Map[String, scalaxb.DataRecord[Any]] } /** Only elements allowed inside */ case class XAllType(annotation: Option[xmlschema.XAnnotation] = None, xParticleOption3: Seq[scalaxb.DataRecord[xmlschema.XParticleOption]] = Nil, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAllable trait XProcessContents object XProcessContents { def fromString(value: String, scope: scala.xml.NamespaceBinding): XProcessContents = value match { case "skip" => XSkip case "lax" => XLax case "strict" => XStrict } } case object XSkip extends XProcessContents { override def toString = "skip" } case object XLax extends XProcessContents { override def toString = "lax" } case object XStrict extends XProcessContents { override def toString = "strict" } trait XWildcardable extends XAnnotatedable { val annotation: Option[xmlschema.XAnnotation] val id: Option[String] val namespace: String val processContents: xmlschema.XProcessContents val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XWildcard(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, namespace: String, processContents: xmlschema.XProcessContents, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XWildcardable case class XAny(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, namespace: String, processContents: xmlschema.XProcessContents, minOccurs: BigInt, maxOccurs: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XWildcardable with XNestedParticleOption with XParticleOption trait XAttributeGroup extends XAnnotatedable { val annotation: Option[xmlschema.XAnnotation] val xAttrDeclsSequence3: xmlschema.XAttrDeclsSequence val id: Option[String] val name: Option[String] val ref: Option[javax.xml.namespace.QName] val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XNamedAttributeGroup(annotation: Option[xmlschema.XAnnotation] = None, xAttrDeclsSequence3: xmlschema.XAttrDeclsSequence, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAttributeGroup with XRedefinableOption case class XAttributeGroupRef(annotation: Option[xmlschema.XAnnotation] = None, xAttrDeclsSequence3: xmlschema.XAttrDeclsSequence, id: Option[String] = None, name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAttributeGroup with XAttrDeclsOption1 case class XInclude(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, schemaLocation: java.net.URI, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XSchemaOption case class XRedefine(xredefineoption: Seq[scalaxb.DataRecord[Any]] = Nil, schemaLocation: java.net.URI, id: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XOpenAttrsable with XSchemaOption trait XRedefineOption case class XImport(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, namespace: Option[java.net.URI] = None, schemaLocation: Option[java.net.URI] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XSchemaOption case class XSelector(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, xpath: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable case class XField(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, xpath: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable trait XKeybasable extends XAnnotatedable with XIdentityConstraintOption { val annotation: Option[xmlschema.XAnnotation] val selector: xmlschema.XSelector val field: Seq[xmlschema.XField] val id: Option[String] val name: String val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XKeybase(annotation: Option[xmlschema.XAnnotation] = None, selector: xmlschema.XSelector, field: Seq[xmlschema.XField] = Nil, id: Option[String] = None, name: String, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XKeybasable case class XKeyref(annotation: Option[xmlschema.XAnnotation] = None, selector: xmlschema.XSelector, field: Seq[xmlschema.XField] = Nil, id: Option[String] = None, name: String, refer: javax.xml.namespace.QName, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XKeybasable with XIdentityConstraintOption case class XNotation(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, name: String, public: Option[String] = None, system: Option[java.net.URI] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XSchemaTopOption case class XAppinfo(mixed: Seq[scalaxb.DataRecord[Any]] = Nil, source: Option[java.net.URI] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotationOption case class XDocumentation(mixed: Seq[scalaxb.DataRecord[Any]] = Nil, source: Option[java.net.URI] = None, xmllang: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotationOption case class XAnnotation(xannotationoption: Seq[scalaxb.DataRecord[xmlschema.XAnnotationOption]] = Nil, id: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XOpenAttrsable with XSchemaOption with XRedefineOption trait XAnnotationOption /** Not the real urType, but as close an approximation as we can get in the XML representation */ case class XAnyType(mixed: Seq[scalaxb.DataRecord[Any]] = Nil, attributes: Map[String, scalaxb.DataRecord[Any]]) trait XDerivationControl object XDerivationControl { def fromString(value: String, scope: scala.xml.NamespaceBinding): XDerivationControl = value match { case "substitution" => XSubstitution case "extension" => XExtension case "restriction" => XRestrictionValue case "list" => XListValue case "union" => XUnionValue } } case object XSubstitution extends XDerivationControl { override def toString = "substitution" } case object XExtension extends XDerivationControl { override def toString = "extension" } case object XRestrictionValue extends XDerivationControl { override def toString = "restriction" } case object XListValue extends XDerivationControl { override def toString = "list" } case object XUnionValue extends XDerivationControl { override def toString = "union" } trait XSimpleType extends XAnnotatedable { val annotation: Option[xmlschema.XAnnotation] val xSimpleDerivationOption3: scalaxb.DataRecord[xmlschema.XSimpleDerivationOption] val id: Option[String] val finalValue: Option[String] val name: Option[String] val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XTopLevelSimpleType(annotation: Option[xmlschema.XAnnotation] = None, xSimpleDerivationOption3: scalaxb.DataRecord[xmlschema.XSimpleDerivationOption], id: Option[String] = None, finalValue: Option[String] = None, name: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XSimpleType with XRedefinableOption case class XLocalSimpleType(annotation: Option[xmlschema.XAnnotation] = None, xSimpleDerivationOption3: scalaxb.DataRecord[xmlschema.XSimpleDerivationOption], id: Option[String] = None, finalValue: Option[String] = None, name: Option[String] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XSimpleType with XElementOption with XTopLevelElementOption with XLocalElementableOption with XNarrowMaxMinOption /** base attribute and simpleType child are mutually exclusive, but one or other is required */ case class XRestriction(annotation: Option[xmlschema.XAnnotation] = None, xSimpleRestrictionModelSequence3: xmlschema.XSimpleRestrictionModelSequence, id: Option[String] = None, base: Option[javax.xml.namespace.QName] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XSimpleDerivationOption /** itemType attribute and simpleType child are mutually exclusive, but one or other is required */ case class XList(annotation: Option[xmlschema.XAnnotation] = None, simpleType: Option[xmlschema.XLocalSimpleType] = None, id: Option[String] = None, itemType: Option[javax.xml.namespace.QName] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XSimpleDerivationOption /** memberTypes attribute must be non-empty or there must be at least one simpleType child */ case class XUnion(annotation: Option[xmlschema.XAnnotation] = None, simpleType: Seq[xmlschema.XLocalSimpleType] = Nil, id: Option[String] = None, memberTypes: Option[Seq[javax.xml.namespace.QName]] = None, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XAnnotatedable with XSimpleDerivationOption trait XFacetable extends XAnnotatedable with XFacetsOption { val annotation: Option[xmlschema.XAnnotation] val id: Option[String] val value: String val fixed: Boolean val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XFacet(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, value: String, fixed: Boolean, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XFacetable trait XNoFixedFacetable extends XFacetable with XFacetsOption { val annotation: Option[xmlschema.XAnnotation] val id: Option[String] val value: String val fixed: Boolean val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XNoFixedFacet(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, value: String, fixed: Boolean, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XNoFixedFacetable trait XNumFacetable extends XFacetable with XFacetsOption { val annotation: Option[xmlschema.XAnnotation] val id: Option[String] val value: String val fixed: Boolean val attributes: Map[String, scalaxb.DataRecord[Any]] } case class XNumFacet(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, value: String, fixed: Boolean, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XNumFacetable case class XTotalDigits(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, value: String, fixed: Boolean, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XNumFacetable with XFacetsOption trait XValue object XValue { def fromString(value: String, scope: scala.xml.NamespaceBinding): XValue = value match { case "preserve" => XPreserve case "replace" => XReplace case "collapse" => XCollapse } } case object XPreserve extends XValue { override def toString = "preserve" } case object XReplace extends XValue { override def toString = "replace" } case object XCollapse extends XValue { override def toString = "collapse" } case class XWhiteSpace(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, value: String, fixed: Boolean, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XFacetable with XFacetsOption case class XPattern(annotation: Option[xmlschema.XAnnotation] = None, id: Option[String] = None, value: String, fixed: Boolean, attributes: Map[String, scalaxb.DataRecord[Any]]) extends XNoFixedFacetable with XFacetsOption case class XSimpleRestrictionModelSequence(simpleType: Option[xmlschema.XLocalSimpleType] = None, xFacetsOption2: Seq[scalaxb.DataRecord[xmlschema.XFacetsOption]] = Nil) trait XFacetsOption trait XSimpleDerivationOption trait XIdentityConstraintOption case class XAllModelSequence(annotation: Option[xmlschema.XAnnotation] = None, xallmodeloption1: Seq[scalaxb.DataRecord[xmlschema.XNarrowMaxMin]] = Nil) trait XAllModelOption1 trait XComplexTypeModelOption case class XComplexTypeModelSequence1(xTypeDefParticleOption1: Option[scalaxb.DataRecord[xmlschema.XTypeDefParticleOption]] = None, xAttrDeclsSequence2: xmlschema.XAttrDeclsSequence) extends XComplexTypeModelOption case class XAttrDeclsSequence(xattrdeclsoption1: Seq[scalaxb.DataRecord[xmlschema.XAttrDeclsOption1]] = Nil, anyAttribute: Option[xmlschema.XWildcardable] = None) trait XAttrDeclsOption1 trait XParticleOption trait XNestedParticleOption trait XTypeDefParticleOption trait XRedefinableOption trait XSchemaTopOption /** for element, group and attributeGroup, which both define and reference */ case class XDefRef(name: Option[String] = None, ref: Option[javax.xml.namespace.QName] = None) /** for all particles */ case class XOccurs(minOccurs: BigInt, maxOccurs: String)
eed3si9n/scalaxb
cli/src_managed/xmlschema/xmlschema.scala
Scala
mit
33,431
package c1.w6 object numberOfQueens extends App { def queens(n: Int): Set[List[Int]] = { def placeQueen(row: Int): Set[List[Int]] = { if (row == 0) Set(Nil) else { for { candidate <- placeQueen(row - 1) // create all rows N col <- 0 until n // for each column if isSafe(row, col, candidate) } yield col :: candidate } } placeQueen(n) } def isSafe(cr: Int, col: Int, queens: List[Int]): Boolean = { val row = queens.length val queensWithRow = (row - 1 to 0 by -1) zip queens val b = queensWithRow forall { case (r, c) => col != c && math.abs(col - c) != row - r } println(s"row=$cr col=$col isSafe=$b queens=$queens") b } def show(queens: List[Int]): String = { val lines = for (col <- queens.reverse) yield Vector.fill(queens.length)("*").updated(col, "X ").mkString "\\n" + (lines mkString "\\n") } queens(4) foreach (q => println(show(q))) }
lwo/lwo.github.io
src/main/scala/c1/w6/numberOfQueens.scala
Scala
gpl-3.0
982
package com.github.j5ik2o.reactive.redis.pool import java.util.UUID import akka.NotUsed import akka.stream.scaladsl.Flow import com.github.j5ik2o.reactive.redis.command.CommandRequestBase import com.github.j5ik2o.reactive.redis.{ PeerConfig, RedisConnection } import io.github.andrebeat.pool.Lease import monix.eval.Task import monix.execution.Scheduler private[redis] final case class ScalaPoolConnection(underlying: Lease[RedisConnection]) extends RedisConnection { private val underlyingCon = underlying.get() override def id: UUID = underlyingCon.id override def peerConfig: PeerConfig = underlyingCon.peerConfig override def shutdown(): Unit = underlyingCon.shutdown() override def toFlow[C <: CommandRequestBase](parallelism: Int)( implicit scheduler: Scheduler ): Flow[C, C#Response, NotUsed] = underlyingCon.toFlow(parallelism) override def send[C <: CommandRequestBase](cmd: C): Task[cmd.Response] = underlyingCon.send(cmd) }
j5ik2o/reactive-redis
pool-scala/src/main/scala/com/github/j5ik2o/reactive/redis/pool/ScalaPoolConnection.scala
Scala
mit
965
package org.stanoq.crawler import java.util.Collections import java.util.concurrent.{ConcurrentHashMap, TimeUnit} import akka.actor.ActorSystem import akka.event.Logging import org.jsoup.nodes.Document import org.jsoup.{Connection, HttpStatusException, Jsoup} import org.stanoq.crawler.model.{ConfigProperties, Page} import scala.collection.JavaConverters._ import scala.util.Try class Crawler(config:ConfigProperties){ val logger = Logging(ActorSystem(), getClass) val visitedPages = createSet[String] private val domain:String = config.getDomain val root: Page = new Page(domain, domain,0,0,0,createSet[Page]) def process(url: String="") = { logger.info("Processing " + config.url + url) crawl(config.url + url, 1, root) root.statusCode = 200 this } private def crawl(url: String, depth: Int, prev: Page) { if (visitedPages.contains(url.substring(0,url.length-1)) || !visitedPages.add(url)) return val (page,links) = getPage(url,prev) if(page.statusCode!=200) return prev.addChild(page) logger.info(url + " "+links.size) if(depth > config.depthLimit) return links.par.foreach(link => crawl(link, depth + 1, page)) } private def createSet[T] = Collections.newSetFromMap(new ConcurrentHashMap[T, java.lang.Boolean]).asScala private def getPage(url: String, prev:Page): (Page,List[String]) = { def parseLinksToVisit(doc: Document): List[String] ={ def predicate(l: String) = (!(l.trim.length<7 || l.startsWith("mailto"))) && l.contains(domain) doc.select("a").iterator().asScala.toStream.map(_.attr("abs:href")).filter(predicate).toList } def getDocument(con: Connection):(Page,List[String]) = { val time = System.nanoTime() val res = con.execute() val pageSize = res.bodyAsBytes().size val timeToLoad = TimeUnit.MILLISECONDS.convert(System.nanoTime()-time, TimeUnit.NANOSECONDS) val doc = res.parse() val links = parseLinksToVisit(doc) (new Page(url, doc.title(), 200,timeToLoad,pageSize,createSet[Page]),parseLinksToVisit(doc)) } (Try(Jsoup.connect(url).userAgent("Mozilla/5.0").timeout(30 * 1000)).map(getDocument).recover { case e: HttpStatusException => logger.error(e.getStatusCode + " :: on " + url); val errPage = new Page(url,e.getMessage,e.getStatusCode,4040,9000,createSet[Page]) prev.addChild(errPage); (errPage, List()) case e: Exception => logger.error(e.getMessage + " :: on " + url); val errPage = new Page(url,e.getMessage,500,5000,9000,createSet[Page]) prev.addChild(errPage);(errPage, List()) }).get } }
olka/stanoq
src/main/scala/org/stanoq/crawler/Crawler.scala
Scala
mit
2,620
package lib sealed abstract class SessionAttribute(val key: String) object SessionAttribute { case object LoginUser extends SessionAttribute("login_user") case object Ref extends SessionAttribute("ref") case object UploadPolicy extends SessionAttribute("upload_policy") case object ResetPasswordToken extends SessionAttribute("reset_password_token") }
atware/sharedocs
src/main/scala/lib/SessionAttribute.scala
Scala
mit
361
package org.jetbrains.plugins.scala.failed.annotator import com.intellij.lang.annotation.AnnotationHolder import com.intellij.psi.{PsiErrorElement, PsiReference} import org.jetbrains.plugins.scala.annotator.AnnotatorHolderMock import org.jetbrains.plugins.scala.annotator.quickfix.ReportHighlightingErrorQuickFix import org.jetbrains.plugins.scala.base.ScalaLightCodeInsightFixtureTestAdapter import org.jetbrains.plugins.scala.lang.psi.api.base.types.{ScTypeElement, ScTypeElementExt} import org.jetbrains.plugins.scala.lang.psi.api.expr.{ScBlockExpr, ScExpression} import org.jetbrains.plugins.scala.lang.psi.api.statements.ScPatternDefinition import org.jetbrains.plugins.scala.lang.psi.types.ScTypeExt import org.jetbrains.plugins.scala.lang.psi.types.api.ScTypePresentation import org.jetbrains.plugins.scala.{PerfCycleTests, ScalaBundle} import org.junit.Assert._ import org.junit.experimental.categories.Category /** * User: Dmitry.Naydanov * Date: 23.03.16. * * */ @Category(Array(classOf[PerfCycleTests])) class OverloadingTest extends ScalaLightCodeInsightFixtureTestAdapter { //TODO this class contains a fair amount of a copy-paste code, however refactoring isn't practical here as the class is to be removed soon import org.jetbrains.plugins.scala.extensions._ protected def collectMessages(fileText: String) = { myFixture.configureByText("dummy.scala", fileText) val file = myFixture.getFile val mock = new AnnotatorHolderMock(file) assertEquals(Nil, file.depthFirst().filterByType[PsiErrorElement].map(_.getText).toList) assertEquals(Nil, file.depthFirst().filterByType[PsiReference] .filter(_.resolve == null).map(_.getElement.getText).toList) file.depthFirst().foreach { case it: ScPatternDefinition => annotate(it, mock, typeAware = true) case _ => } mock.annotations } protected def annotate(element: ScPatternDefinition, holder: AnnotationHolder, typeAware: Boolean): Unit = { for (expr <- element.expr; element <- element.children.findByType[ScTypeElement]) checkConformance(expr, element, holder) } private def checkConformance(expression: ScExpression, typeElement: ScTypeElement, holder: AnnotationHolder) { expression.getTypeAfterImplicitConversion().tr.foreach {actual => val expected = typeElement.calcType if (!actual.conforms(expected)) { val expr = expression match { case b: ScBlockExpr => b.getRBrace.map(_.getPsi).getOrElse(b) case _ => expression } val (actualText, expText) = ScTypePresentation.different(actual, expected) val annotation = holder.createErrorAnnotation(expr, ScalaBundle.message("type.mismatch.found.required", actualText, expText)) annotation.registerFix(ReportHighlightingErrorQuickFix) } } } def testSCL9908(): Unit = assert( collectMessages( """ |class Test {
 | def foo(s: String, args: Any*) = println("foo(s, args)")
 | def foo(x: Any) = println("foo(x)")
 |
 | def func(args: Array[String]) = {
 | foo("Hello") // red code; 'foo(s, args)' with scalac
 | }
 |} """.stripMargin).isEmpty ) def testSCL7442(): Unit = assert( collectMessages( """ |class Test {
 | def set(value: Any) : Unit = { | val (a, b, c, d) = value.asInstanceOf[(Int, Int, Int, Int)] | set(a, b, c, d) | } | def set(aValue: Int, bValue: Int, cValue: Int, dValue: Int) = { | //... | } | (set _).tupled((1, 2, 3, 4)) |} """.stripMargin).isEmpty ) def testSCL10158(): Unit = assert( collectMessages( """ |class Test {
 | val lock = new AnyRef | class Test { | def run: Unit = this.synchronized(println("sync")) | def synchronized[T](exec: => T): Unit = lock.synchronized(exec) | } |} """.stripMargin).isEmpty ) def testSCL10183(): Unit = assert( collectMessages( """ |class MyClass { | def foo[T](): T = ??? | | val value = foo[MyTrait] | value.get _ |} | |trait MyTrait { | def get() = ??? | def get[A](arg: Any => Any) = ??? |} """.stripMargin).isEmpty ) def testSCL10295(): Unit = assert( collectMessages( """ |import java.lang.reflect.Field |import scala.collection.mutable | |class Test { | | def instanceFieldsOf(v: AnyRef): Array[Field] = ??? | def instanceFieldsOf(v: AnyRef, | cache: mutable.Map[Class[_], Array[Field]], | newFieldsHandler: Field => Unit = v => ()) | : Array[Field] = ??? | | def valueAndInstanceFieldTuplesOf(v: AnyRef, | cache: mutable.Map[Class[_], Array[Field]], | newFieldsHandler: Field => Unit = v => ()) | : Stream[(AnyRef, Field)] = { | val fields: Array[Field] = this.instanceFieldsOf(v, cache, newFieldsHandler) | fields.toStream.map { f => (f.get(v), f) } | } |} """.stripMargin).isEmpty ) }
ilinum/intellij-scala
test/org/jetbrains/plugins/scala/failed/annotator/OverloadingTest.scala
Scala
apache-2.0
5,378
package net.mm.composer import com.twitter.finatra.{Controller, ResponseBuilder} import com.twitter.logging.Logger import com.twitter.util.Future import net.mm.composer.properties.Property import net.mm.composer.relations.RelationJsonComposer trait CompositionResponseBuilder { self: Controller => protected def relationComposer: RelationJsonComposer implicit class CompositionSupport(render: ResponseBuilder) { def composedJson[T](obj: Any)(implicit properties: Seq[Property], m: Manifest[T]): Future[ResponseBuilder] = composedJson(obj, m.runtimeClass) def composedJson(obj: Any, clazz: Class[_])(implicit properties: Seq[Property]): Future[ResponseBuilder] = { relationComposer.compose(obj, clazz)(properties) .map(render.json) .onFailure(Logger.get.warning(_, "Relation composition failed")) } } }
mosche/finatra-composition-proxy
composition-proxy/src/main/scala/net/mm/composer/CompositionResponseBuilder.scala
Scala
mit
851
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.flink.table.descriptors import org.apache.flink.table.descriptors.StreamTableDescriptorValidator.{UPDATE_MODE, UPDATE_MODE_VALUE_APPEND, UPDATE_MODE_VALUE_RETRACT, UPDATE_MODE_VALUE_UPSERT} import org.apache.flink.util.Preconditions import org.junit.Assert.assertEquals import org.junit.Test import scala.collection.JavaConverters._ abstract class DescriptorTestBase { /** * Returns a set of valid descriptors. * This method is implemented in both Scala and Java. */ def descriptors(): java.util.List[Descriptor] /** * Returns a set of properties for each valid descriptor. * This code is implemented in both Scala and Java. */ def properties(): java.util.List[java.util.Map[String, String]] /** * Returns a validator that can validate all valid descriptors. */ def validator(): DescriptorValidator @Test def testValidation(): Unit = { val d = descriptors().asScala val p = properties().asScala Preconditions.checkArgument(d.length == p.length) d.zip(p).foreach { case (desc, props) => verifyProperties(desc, props.asScala.toMap) } } def verifyProperties(descriptor: Descriptor, expected: Map[String, String]): Unit = { val normProps = new DescriptorProperties descriptor.addProperties(normProps) // test produced properties assertEquals(expected, normProps.asMap.asScala.toMap) // test validation logic validator().validate(normProps) } def addPropertyAndVerify( descriptor: Descriptor, property: String, invalidValue: String): Unit = { val properties = new DescriptorProperties descriptor.addProperties(properties) properties.unsafePut(property, invalidValue) validator().validate(properties) } def removePropertyAndVerify(descriptor: Descriptor, removeProperty: String): Unit = { val properties = new DescriptorProperties descriptor.addProperties(properties) properties.unsafeRemove(removeProperty) validator().validate(properties) } } class TestTableDescriptor(connector: ConnectorDescriptor) extends TableDescriptor with SchematicDescriptor[TestTableDescriptor] with StreamableDescriptor[TestTableDescriptor] { private var formatDescriptor: Option[FormatDescriptor] = None private var schemaDescriptor: Option[Schema] = None private var updateMode: Option[String] = None override private[flink] def addProperties(properties: DescriptorProperties): Unit = { connector.addProperties(properties) formatDescriptor.foreach(_.addProperties(properties)) schemaDescriptor.foreach(_.addProperties(properties)) updateMode.foreach(mode => properties.putString(UPDATE_MODE, mode)) } override def withFormat(format: FormatDescriptor): TestTableDescriptor = { this.formatDescriptor = Some(format) this } override def withSchema(schema: Schema): TestTableDescriptor = { this.schemaDescriptor = Some(schema) this } override def inAppendMode(): TestTableDescriptor = { updateMode = Some(UPDATE_MODE_VALUE_APPEND) this } override def inRetractMode(): TestTableDescriptor = { updateMode = Some(UPDATE_MODE_VALUE_RETRACT) this } override def inUpsertMode(): TestTableDescriptor = { updateMode = Some(UPDATE_MODE_VALUE_UPSERT) this } }
zhangminglei/flink
flink-libraries/flink-table/src/test/scala/org/apache/flink/table/descriptors/DescriptorTestBase.scala
Scala
apache-2.0
4,122
/* * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package wvlet.airframe.legacy import wvlet.airspec.AirSpec import wvlet.log.LogSupport import wvlet.airframe._ /** */ class AssistedInjectionTest extends AirSpec { import AssistedInjectionTest._ test("support assisted injection") { newSilentDesign .bind[MyService].toInstance("hello") .withSession { session => val p = session.build[NamedServiceProvider] val a1 = p.provider("A1", session) val a2 = p.provider("A2", session) a1.name shouldBe "A1" a2.name shouldBe "A2" a1.service shouldBe "hello" a2.service shouldBe "hello" val a3 = assistedInjector("A3", session) a3.name shouldBe "A3" a3.service shouldBe "hello" } } } object AssistedInjectionTest extends LogSupport { type MyService = String trait NamedService { val name: String val service = bind[MyService] } trait NamedServiceProvider { val provider = (givenName: String, ss: Session) => new NamedService with DISupport { override def session: Session = ss val name: String = givenName } } def assistedInjector(serviceName: String, ss: Session): NamedService = new NamedService with DISupport { override def session: Session = ss val name: String = serviceName } }
wvlet/airframe
airframe-di/src/test/scala-2/wvlet/airframe/legacy/AssistedInjectionTest.scala
Scala
apache-2.0
1,904
package io.hydrosphere.mist.jobs.resolvers import java.nio.file.{Files, Paths} import akka.http.scaladsl.model.{HttpRequest, HttpResponse} import akka.stream.scaladsl.Flow import org.apache.commons.codec.digest.DigestUtils import org.scalatest.{FunSuite, Matchers} import scala.concurrent.duration.Duration import scala.concurrent.{Await, Future, Promise} class MavenArtifactResolverTest extends FunSuite with Matchers { test("maven artifact") { val remote = MavenArtifact("io.hydrosphere", "mist", "0.0.1") remote.jarName shouldBe "mist-0.0.1.jar" remote.jarPath shouldBe "io/hydrosphere/mist/0.0.1/mist-0.0.1.jar" } test("construct resolver from path") { val path = "mvn://http://localhost:8081/artifactory/releases :: io.hydrosphere % mist_2.10 % 0.0.1" val resolver = MavenArtifactResolver.fromPath(path) resolver.repoUrl shouldBe "http://localhost:8081/artifactory/releases" resolver.artifact shouldBe MavenArtifact("io.hydrosphere", "mist_2.10", "0.0.1") } test("resolver over http") { import akka.http.scaladsl.model.StatusCodes._ // maven-like repository mock val routes = Flow[HttpRequest].map { request => val uri = request.uri.toString() if (uri.endsWith(".jar")) { HttpResponse(status = OK, entity = "JAR CONTENT") } else if (uri.endsWith(".sha1")) { val data = DigestUtils.sha1Hex("JAR CONTENT") HttpResponse(status = OK, entity = data) } else { HttpResponse(status = NotFound, entity = s"Not found ${request.uri}") } } val future = MockHttpServer.onServer(routes, binding => { val port = binding.localAddress.getPort val url = s"http://localhost:$port/artifactory/libs-release-local" val artifact = MavenArtifact("mist_examples", "mist_examples_2.10", "0.10.0") val resolver = MavenArtifactResolver(url, artifact, "target") resolver.resolve() }) val file = Await.result(future, Duration.Inf) file.exists() shouldBe true val content = Files.readAllBytes(Paths.get(file.getAbsolutePath)) new String(content) shouldBe "JAR CONTENT" } object MockHttpServer { import akka.actor.ActorSystem import akka.http.scaladsl.Http import akka.stream.ActorMaterializer import akka.util.Timeout import scala.concurrent.duration._ def onServer[A]( routes: Flow[HttpRequest, HttpResponse, Unit], f: (Http.ServerBinding) => A): Future[A] = { implicit val system = ActorSystem("mock-http-cli") implicit val materializer = ActorMaterializer() implicit val executionContext = system.dispatcher implicit val timeout = Timeout(1.seconds) val binding = Http().bindAndHandle(routes, "localhost", 0) val close = Promise[Http.ServerBinding] close.future .flatMap(binding => binding.unbind()) .onComplete(_ => { system.shutdown() system.awaitTermination() }) val result = binding.flatMap(binding => { try{ Future.successful(f(binding)) } catch { case e: Throwable => Future.failed(e) } finally { close.success(binding) } }) result } } }
KineticCookie/mist
src/test/scala/io/hydrosphere/mist/jobs/resolvers/MavenArtifactResolverTest.scala
Scala
apache-2.0
3,236
package com.mesosphere.http import cats.instances.list._ import cats.instances.try_._ import cats.syntax.traverse._ import scala.util.Success import scala.util.Try object CompoundMediaTypeParser { def parse(s: String): Try[CompoundMediaType] = { s.split(',').toList.filterNot(_.trim.isEmpty) match { case Nil => Success(new CompoundMediaType(Set.empty)) case mts => mts.map(MediaType.parse) .sequence .map { mediaTypes => CompoundMediaType(backfillParams(mediaTypes)._2.toSet) } } } /** * This method implements the logic necessary to "propagate parameters" to all MediaTypes specified as part of * an Accept header. Since we have a concrete type that represents Media Type we need to "back fill" the parameters * specified on media types that come later in the string to those earlier in the string where those earlier * media types do not have parameters defined. * * * For example, given the Accept header value of `* application/xml;q=0.8,application/json,application/x-protobuf;q=0.9` * We will end up with three media types: * * application/xml;q=0.8 * * application/json;q=0.9 * * application/x-protobuf;q=0.9 * * @see https://tools.ietf.org/html/rfc7231#section-5.3.2 for full details on the spec for the Accept header * and content negotiation. */ private[this] def backfillParams( mts: List[MediaType] ): (Map[String, String], List[MediaType]) = { mts match { case Nil => (Map.empty, Nil) case x :: xs => // walk down the list of media types backfillParams(xs) match { case (m, l) => if (x.parameters.isEmpty) { // if the current media type doesn't have parameters set on it set it to be the parameters returned // from the next media type in the list m -> (x.copy(parameters = m) :: l) } else { // if the current media type does have parameters set on it, leave them intact and pass // up for previous media type in the list x.parameters -> (x :: l) } } } } }
dcos/cosmos
cosmos-common/src/main/scala/com/mesosphere/http/CompoundMediaTypeParser.scala
Scala
apache-2.0
2,196
/* Copyright 2010 the original author or authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package net.gumbix.hl7dsl.DSL import org.hl7.rim.{RimObjectFactory, Supply} import org.hl7.types._ /** * Wrapper Class for RIM Class "Supply" * @author Ahmet Gül ([email protected]) */ class SupplyDSL(supply: Supply) extends ActDSL(supply) { def this() = { this (RimObjectFactory.getInstance.createRimObject("Supply").asInstanceOf[Supply]) } /** * @return PQ */ def quantity: PQ = supply.getQuantity def quantity_=(v: PQ) { supply.setQuantity(v) } /** * @return IVL[TS] */ def expectedUseTime: IVL[TS] = supply.getExpectedUseTime def expectedUseTime_=(v: IVL[TS]) { supply.setExpectedUseTime(v) } }
markusgumbel/dshl7
core/src/main/scala/net/gumbix/hl7dsl/DSL/SupplyDSL.scala
Scala
apache-2.0
1,263
package decoupledwithfactory trait MessageProvider { def getMessage: String }
BBK-PiJ-2015-67/sdp-portfolio
exercises/week02/di-scala/src/decoupledwithfactory/MessageProvider.scala
Scala
unlicense
80
/* * Copyright 2017 Datamountaineer. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.datamountaineer.streamreactor.connect.elastic6 import java.nio.ByteBuffer import com.datamountaineer.streamreactor.connect.json.SimpleJsonConverter import com.fasterxml.jackson.databind.JsonNode import com.landoop.connect.sql.StructSql._ import com.landoop.json.sql.JacksonJson import com.landoop.json.sql.JsonSql._ import com.landoop.sql.Field import com.typesafe.scalalogging.StrictLogging import org.apache.kafka.connect.data.{Schema, Struct} import scala.util.{Failure, Success, Try} private object TransformAndExtractPK extends StrictLogging { lazy val simpleJsonConverter = new SimpleJsonConverter() def apply(fields: Seq[Field], ignoredFields: Seq[Field], primaryKeysPaths: Seq[Vector[String]], schema: Schema, value: Any, withStructure: Boolean): (JsonNode, Seq[Any]) = { def raiseException(msg: String, t: Throwable) = throw new IllegalArgumentException(msg, t) if (value == null) { if (schema == null || !schema.isOptional) { raiseException("Null value is not allowed.", null) } else null } else { if (schema != null) { schema.`type`() match { case Schema.Type.BYTES => //we expected to be json val array = value match { case a: Array[Byte] => a case b: ByteBuffer => b.array() case other => raiseException("Invalid payload:$other for schema Schema.BYTES.", null) } Try(JacksonJson.mapper.readTree(array)) match { case Failure(e) => raiseException("Invalid json.", e) case Success(json) => Try(json.sql(fields, !withStructure)) match { case Failure(e) => raiseException(s"A KCQL exception occurred. ${e.getMessage}", e) case Success(jn) => (jn, primaryKeysPaths.map(PrimaryKeyExtractor.extract(json, _))) } } case Schema.Type.STRING => //we expected to be json Try(JacksonJson.asJson(value.asInstanceOf[String])) match { case Failure(e) => raiseException("Invalid json", e) case Success(json) => Try(json.sql(fields, !withStructure)) match { case Success(jn) => (jn, primaryKeysPaths.map(PrimaryKeyExtractor.extract(json, _))) case Failure(e) => raiseException(s"A KCQL exception occurred.${e.getMessage}", e) } } case Schema.Type.STRUCT => val struct = value.asInstanceOf[Struct] Try(struct.sql(fields, !withStructure)) match { case Success(s) => (simpleJsonConverter.fromConnectData(s.schema(), s), primaryKeysPaths.map(PrimaryKeyExtractor.extract(struct, _))) case Failure(e) => raiseException(s"A KCQL error occurred.${e.getMessage}", e) } case other => raiseException("Can't transform Schema type:$other.", null) } } else { //we can handle java.util.Map (this is what JsonConverter can spit out) value match { case m: java.util.Map[_, _] => val map = m.asInstanceOf[java.util.Map[String, Any]] val jsonNode: JsonNode = JacksonJson.mapper.valueToTree(map) Try(jsonNode.sql(fields, !withStructure)) match { case Success(j) => (j, primaryKeysPaths.map(PrimaryKeyExtractor.extract(jsonNode, _))) case Failure(e) => raiseException(s"A KCQL exception occurred.${e.getMessage}", e) } case s: String => Try(JacksonJson.asJson(value.asInstanceOf[String])) match { case Failure(e) => raiseException("Invalid json.", e) case Success(json) => Try(json.sql(fields, !withStructure)) match { case Success(jn) => (jn, primaryKeysPaths.map(PrimaryKeyExtractor.extract(json, _))) case Failure(e) => raiseException(s"A KCQL exception occurred.${e.getMessage}", e) } } case b: Array[Byte] => Try(JacksonJson.mapper.readTree(b)) match { case Failure(e) => raiseException("Invalid json.", e) case Success(json) => Try(json.sql(fields, !withStructure)) match { case Failure(e) => raiseException(s"A KCQL exception occurred. ${e.getMessage}", e) case Success(jn) => (jn, primaryKeysPaths.map(PrimaryKeyExtractor.extract(json, _))) } } //we take it as String case other => raiseException(s"Value:$other is not handled!", null) } } } } }
datamountaineer/stream-reactor
kafka-connect-elastic6/src/main/scala/com/datamountaineer/streamreactor/connect/elastic6/TransformAndExtractPK.scala
Scala
apache-2.0
5,351
package sativum import peapod.Task abstract class Dag { lazy val name: String = this.getClass.getName protected val sativum: Sativum var endpoints: List[Task[_]] = Nil protected val waitTime = 60000 def endpoint (t: Task[_]) = { endpoints = endpoints :+ t } /** * Returns back if all peas in this Dag are ready, this would only be false in the case of Sensor Tasks * */ def ready(): Boolean = { endpoints.map(sativum(_)).forall{ case s: SativumPea[_] => s.ready() case _ => true } } def run() { endpoints.map(sativum(_)) while(! ready()) { Thread.sleep(waitTime) } endpoints.flatMap(_.parents).foreach(_.delete()) endpoints.par.map(sativum(_).get()) } def view(): String = { peapod.Util.mindfulmachinesDotLink(sativum.dotFormatDiagram()) } }
teachingmachines/sativum
src/main/scala/sativum/Dag.scala
Scala
mit
840
package breeze.linalg import breeze.benchmark.{MyRunner, BreezeBenchmark} import breeze.linalg.operators.DenseVectorSupportMethods import spire.syntax.cfor._ /** * Created by dlwh on 8/14/15. */ class DenseAxpyBenchmark extends BreezeBenchmark { assert(usingNatives) val dv, dv2 = DenseVector.rand(5) def timeSmallDVAxpy(reps: Int) = { var sum = 0.0 cforRange(0 until reps) { rep => axpy(0.042, dv, dv2) } dv2 } def timeSmallDVInlineRange(reps: Int) = { cforRange(0 until reps) { rep => val ad = dv.data val bd = dv2.data cforRange(0 until dv.length) { i => bd(i) += 0.042 * ad(i) } } dv2 } def timeSmallDVScaleAddInline(reps: Int) = { cforRange(0 until reps) { rep => dv(0) += dv2(0) * 0.042 dv(1) += dv2(1) * 0.042 dv(2) += dv2(2) * 0.042 dv(3) += dv2(3) * 0.042 dv(4) += dv2(4) * 0.042 } dv } val largeDV, largeDV2 = DenseVector.rand(400) val largeDM, largeDM2 = DenseMatrix.rand(20, 20) def timeLargeDMAddInPlace(reps: Int) = { cforRange(0 until reps) { rep => largeDM += largeDM2 } } def timeLargeDVAddInPlace(reps: Int) = { cforRange(0 until reps) { rep => largeDV += largeDV2 } } } object DenseAxpyBenchmark extends MyRunner(classOf[DenseAxpyBenchmark]) object DenseAxpyX { def main(args: Array[String]):Unit = { (new DenseAxpyBenchmark).timeSmallDVScaleAddInline(44400000) } }
wstcpyt/breeze
benchmark/src/main/scala/breeze/linalg/DenseAxpyBenchmark.scala
Scala
apache-2.0
1,470
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package kafka.network import java.io.IOException import java.net._ import java.nio.channels._ import java.nio.channels.{Selector => NSelector} import java.util.concurrent._ import java.util.concurrent.atomic._ import com.yammer.metrics.core.Gauge import kafka.cluster.{BrokerEndPoint, EndPoint} import kafka.common.KafkaException import kafka.metrics.KafkaMetricsGroup import kafka.security.CredentialProvider import kafka.server.KafkaConfig import kafka.utils._ import org.apache.kafka.common.Reconfigurable import org.apache.kafka.common.memory.{MemoryPool, SimpleMemoryPool} import org.apache.kafka.common.metrics._ import org.apache.kafka.common.metrics.stats.Meter import org.apache.kafka.common.network.{ChannelBuilder, ChannelBuilders, KafkaChannel, ListenerName, Selectable, Send, Selector => KSelector} import org.apache.kafka.common.requests.{RequestContext, RequestHeader} import org.apache.kafka.common.security.auth.SecurityProtocol import org.apache.kafka.common.utils.{KafkaThread, LogContext, Time} import org.slf4j.event.Level import scala.collection._ import JavaConverters._ import scala.collection.mutable.{ArrayBuffer, Buffer} import scala.util.control.ControlThrowable /** * An NIO socket server. The threading model is * 1 Acceptor thread that handles new connections * Acceptor has N Processor threads that each have their own selector and read requests from sockets * M Handler threads that handle requests and produce responses back to the processor threads for writing. */ class SocketServer(val config: KafkaConfig, val metrics: Metrics, val time: Time, val credentialProvider: CredentialProvider) extends Logging with KafkaMetricsGroup { private val maxQueuedRequests = config.queuedMaxRequests private val maxConnectionsPerIp = config.maxConnectionsPerIp private val maxConnectionsPerIpOverrides = config.maxConnectionsPerIpOverrides private val logContext = new LogContext(s"[SocketServer brokerId=${config.brokerId}] ") this.logIdent = logContext.logPrefix private val memoryPoolSensor = metrics.sensor("MemoryPoolUtilization") private val memoryPoolDepletedPercentMetricName = metrics.metricName("MemoryPoolAvgDepletedPercent", "socket-server-metrics") private val memoryPoolDepletedTimeMetricName = metrics.metricName("MemoryPoolDepletedTimeTotal", "socket-server-metrics") memoryPoolSensor.add(new Meter(TimeUnit.MILLISECONDS, memoryPoolDepletedPercentMetricName, memoryPoolDepletedTimeMetricName)) private val memoryPool = if (config.queuedMaxBytes > 0) new SimpleMemoryPool(config.queuedMaxBytes, config.socketRequestMaxBytes, false, memoryPoolSensor) else MemoryPool.NONE val requestChannel = new RequestChannel(maxQueuedRequests) private val processors = new ConcurrentHashMap[Int, Processor]() private var nextProcessorId = 0 private[network] val acceptors = new ConcurrentHashMap[EndPoint, Acceptor]() private var connectionQuotas: ConnectionQuotas = _ private var stoppedProcessingRequests = false /** * Start the socket server. Acceptors for all the listeners are started. Processors * are started if `startupProcessors` is true. If not, processors are only started when * [[kafka.network.SocketServer#startProcessors()]] is invoked. Delayed starting of processors * is used to delay processing client connections until server is fully initialized, e.g. * to ensure that all credentials have been loaded before authentications are performed. * Acceptors are always started during `startup` so that the bound port is known when this * method completes even when ephemeral ports are used. Incoming connections on this server * are processed when processors start up and invoke [[org.apache.kafka.common.network.Selector#poll]]. * * @param startupProcessors Flag indicating whether `Processor`s must be started. */ def startup(startupProcessors: Boolean = true) { this.synchronized { connectionQuotas = new ConnectionQuotas(maxConnectionsPerIp, maxConnectionsPerIpOverrides) createAcceptorAndProcessors(config.numNetworkThreads, config.listeners) if (startupProcessors) { startProcessors() } } newGauge("NetworkProcessorAvgIdlePercent", new Gauge[Double] { def value = SocketServer.this.synchronized { val ioWaitRatioMetricNames = processors.values.asScala.map { p => metrics.metricName("io-wait-ratio", "socket-server-metrics", p.metricTags) } ioWaitRatioMetricNames.map { metricName => Option(metrics.metric(metricName)).fold(0.0)(_.value) }.sum / processors.size } } ) newGauge("MemoryPoolAvailable", new Gauge[Long] { def value = memoryPool.availableMemory() } ) newGauge("MemoryPoolUsed", new Gauge[Long] { def value = memoryPool.size() - memoryPool.availableMemory() } ) info("Started " + acceptors.size + " acceptor threads") } /** * Starts processors of all the acceptors of this server if they have not already been started. * This method is used for delayed starting of processors if [[kafka.network.SocketServer#startup]] * was invoked with `startupProcessors=false`. */ def startProcessors(): Unit = synchronized { acceptors.values.asScala.foreach { _.startProcessors() } info(s"Started processors for ${acceptors.size} acceptors") } private def endpoints = config.listeners.map(l => l.listenerName -> l).toMap private def createAcceptorAndProcessors(processorsPerListener: Int, endpoints: Seq[EndPoint]): Unit = synchronized { val sendBufferSize = config.socketSendBufferBytes val recvBufferSize = config.socketReceiveBufferBytes val brokerId = config.brokerId endpoints.foreach { endpoint => val listenerName = endpoint.listenerName val securityProtocol = endpoint.securityProtocol val acceptor = new Acceptor(endpoint, sendBufferSize, recvBufferSize, brokerId, connectionQuotas) KafkaThread.nonDaemon(s"kafka-socket-acceptor-$listenerName-$securityProtocol-${endpoint.port}", acceptor).start() acceptor.awaitStartup() acceptors.put(endpoint, acceptor) addProcessors(acceptor, endpoint, processorsPerListener) } } private def addProcessors(acceptor: Acceptor, endpoint: EndPoint, newProcessorsPerListener: Int): Unit = synchronized { val listenerName = endpoint.listenerName val securityProtocol = endpoint.securityProtocol val listenerProcessors = new ArrayBuffer[Processor]() for (_ <- 0 until newProcessorsPerListener) { val processor = newProcessor(nextProcessorId, connectionQuotas, listenerName, securityProtocol, memoryPool) listenerProcessors += processor requestChannel.addProcessor(processor) nextProcessorId += 1 } listenerProcessors.foreach(p => processors.put(p.id, p)) acceptor.addProcessors(listenerProcessors) } /** * Stop processing requests and new connections. */ def stopProcessingRequests() = { info("Stopping socket server request processors") this.synchronized { acceptors.asScala.values.foreach(_.shutdown()) processors.asScala.values.foreach(_.shutdown()) requestChannel.clear() stoppedProcessingRequests = true } info("Stopped socket server request processors") } def resizeThreadPool(oldNumNetworkThreads: Int, newNumNetworkThreads: Int): Unit = synchronized { info(s"Resizing network thread pool size for each listener from $oldNumNetworkThreads to $newNumNetworkThreads") if (newNumNetworkThreads > oldNumNetworkThreads) { acceptors.asScala.foreach { case (endpoint, acceptor) => addProcessors(acceptor, endpoint, newNumNetworkThreads - oldNumNetworkThreads) } } else if (newNumNetworkThreads < oldNumNetworkThreads) acceptors.asScala.values.foreach(_.removeProcessors(oldNumNetworkThreads - newNumNetworkThreads, requestChannel)) } /** * Shutdown the socket server. If still processing requests, shutdown * acceptors and processors first. */ def shutdown() = { info("Shutting down socket server") this.synchronized { if (!stoppedProcessingRequests) stopProcessingRequests() requestChannel.shutdown() } info("Shutdown completed") } def boundPort(listenerName: ListenerName): Int = { try { acceptors.get(endpoints(listenerName)).serverChannel.socket.getLocalPort } catch { case e: Exception => throw new KafkaException("Tried to check server's port before server was started or checked for port of non-existing protocol", e) } } def addListeners(listenersAdded: Seq[EndPoint]): Unit = synchronized { info(s"Adding listeners for endpoints $listenersAdded") createAcceptorAndProcessors(config.numNetworkThreads, listenersAdded) startProcessors() } def removeListeners(listenersRemoved: Seq[EndPoint]): Unit = synchronized { info(s"Removing listeners for endpoints $listenersRemoved") listenersRemoved.foreach { endpoint => acceptors.asScala.remove(endpoint).foreach(_.shutdown()) } } /* `protected` for test usage */ protected[network] def newProcessor(id: Int, connectionQuotas: ConnectionQuotas, listenerName: ListenerName, securityProtocol: SecurityProtocol, memoryPool: MemoryPool): Processor = { new Processor(id, time, config.socketRequestMaxBytes, requestChannel, connectionQuotas, config.connectionsMaxIdleMs, listenerName, securityProtocol, config, metrics, credentialProvider, memoryPool, logContext ) } /* For test usage */ private[network] def connectionCount(address: InetAddress): Int = Option(connectionQuotas).fold(0)(_.get(address)) /* For test usage */ private[network] def processor(index: Int): Processor = processors.get(index) } /** * A base class with some helper variables and methods */ private[kafka] abstract class AbstractServerThread(connectionQuotas: ConnectionQuotas) extends Runnable with Logging { private val startupLatch = new CountDownLatch(1) // `shutdown()` is invoked before `startupComplete` and `shutdownComplete` if an exception is thrown in the constructor // (e.g. if the address is already in use). We want `shutdown` to proceed in such cases, so we first assign an open // latch and then replace it in `startupComplete()`. @volatile private var shutdownLatch = new CountDownLatch(0) private val alive = new AtomicBoolean(true) def wakeup(): Unit /** * Initiates a graceful shutdown by signaling to stop and waiting for the shutdown to complete */ def shutdown(): Unit = { if (alive.getAndSet(false)) wakeup() shutdownLatch.await() } /** * Wait for the thread to completely start up */ def awaitStartup(): Unit = startupLatch.await /** * Record that the thread startup is complete */ protected def startupComplete(): Unit = { // Replace the open latch with a closed one shutdownLatch = new CountDownLatch(1) startupLatch.countDown() } /** * Record that the thread shutdown is complete */ protected def shutdownComplete(): Unit = shutdownLatch.countDown() /** * Is the server still running? */ protected def isRunning: Boolean = alive.get /** * Close `channel` and decrement the connection count. */ def close(channel: SocketChannel): Unit = { if (channel != null) { debug("Closing connection from " + channel.socket.getRemoteSocketAddress()) connectionQuotas.dec(channel.socket.getInetAddress) CoreUtils.swallow(channel.socket().close(), this, Level.ERROR) CoreUtils.swallow(channel.close(), this, Level.ERROR) } } } /** * Thread that accepts and configures new connections. There is one of these per endpoint. */ private[kafka] class Acceptor(val endPoint: EndPoint, val sendBufferSize: Int, val recvBufferSize: Int, brokerId: Int, connectionQuotas: ConnectionQuotas) extends AbstractServerThread(connectionQuotas) with KafkaMetricsGroup { private val nioSelector = NSelector.open() val serverChannel = openServerSocket(endPoint.host, endPoint.port) private val processors = new ArrayBuffer[Processor]() private val processorsStarted = new AtomicBoolean private[network] def addProcessors(newProcessors: Buffer[Processor]): Unit = synchronized { processors ++= newProcessors if (processorsStarted.get) startProcessors(newProcessors) } private[network] def startProcessors(): Unit = synchronized { if (!processorsStarted.getAndSet(true)) { startProcessors(processors) } } private def startProcessors(processors: Seq[Processor]): Unit = synchronized { processors.foreach { processor => KafkaThread.nonDaemon(s"kafka-network-thread-$brokerId-${endPoint.listenerName}-${endPoint.securityProtocol}-${processor.id}", processor).start() } } private[network] def removeProcessors(removeCount: Int, requestChannel: RequestChannel): Unit = synchronized { // Shutdown `removeCount` processors. Remove them from the processor list first so that no more // connections are assigned. Shutdown the removed processors, closing the selector and its connections. // The processors are then removed from `requestChannel` and any pending responses to these processors are dropped. val toRemove = processors.takeRight(removeCount) processors.remove(processors.size - removeCount, removeCount) toRemove.foreach(_.shutdown()) toRemove.foreach(processor => requestChannel.removeProcessor(processor.id)) } override def shutdown(): Unit = { super.shutdown() synchronized { processors.foreach(_.shutdown()) } } /** * Accept loop that checks for new connection attempts */ def run() { serverChannel.register(nioSelector, SelectionKey.OP_ACCEPT) startupComplete() try { var currentProcessor = 0 while (isRunning) { try { val ready = nioSelector.select(500) if (ready > 0) { val keys = nioSelector.selectedKeys() val iter = keys.iterator() while (iter.hasNext && isRunning) { try { val key = iter.next iter.remove() if (key.isAcceptable) { val processor = synchronized { currentProcessor = currentProcessor % processors.size processors(currentProcessor) } accept(key, processor) } else throw new IllegalStateException("Unrecognized key state for acceptor thread.") // round robin to the next processor thread, mod(numProcessors) will be done later currentProcessor = currentProcessor + 1 } catch { case e: Throwable => error("Error while accepting connection", e) } } } } catch { // We catch all the throwables to prevent the acceptor thread from exiting on exceptions due // to a select operation on a specific channel or a bad request. We don't want // the broker to stop responding to requests from other clients in these scenarios. case e: ControlThrowable => throw e case e: Throwable => error("Error occurred", e) } } } finally { debug("Closing server socket and selector.") CoreUtils.swallow(serverChannel.close(), this, Level.ERROR) CoreUtils.swallow(nioSelector.close(), this, Level.ERROR) shutdownComplete() } } /* * Create a server socket to listen for connections on. */ private def openServerSocket(host: String, port: Int): ServerSocketChannel = { val socketAddress = if(host == null || host.trim.isEmpty) new InetSocketAddress(port) else new InetSocketAddress(host, port) val serverChannel = ServerSocketChannel.open() serverChannel.configureBlocking(false) if (recvBufferSize != Selectable.USE_DEFAULT_BUFFER_SIZE) serverChannel.socket().setReceiveBufferSize(recvBufferSize) try { serverChannel.socket.bind(socketAddress) info("Awaiting socket connections on %s:%d.".format(socketAddress.getHostString, serverChannel.socket.getLocalPort)) } catch { case e: SocketException => throw new KafkaException("Socket server failed to bind to %s:%d: %s.".format(socketAddress.getHostString, port, e.getMessage), e) } serverChannel } /* * Accept a new connection */ def accept(key: SelectionKey, processor: Processor) { val serverSocketChannel = key.channel().asInstanceOf[ServerSocketChannel] val socketChannel = serverSocketChannel.accept() try { connectionQuotas.inc(socketChannel.socket().getInetAddress) socketChannel.configureBlocking(false) socketChannel.socket().setTcpNoDelay(true) socketChannel.socket().setKeepAlive(true) if (sendBufferSize != Selectable.USE_DEFAULT_BUFFER_SIZE) socketChannel.socket().setSendBufferSize(sendBufferSize) debug("Accepted connection from %s on %s and assigned it to processor %d, sendBufferSize [actual|requested]: [%d|%d] recvBufferSize [actual|requested]: [%d|%d]" .format(socketChannel.socket.getRemoteSocketAddress, socketChannel.socket.getLocalSocketAddress, processor.id, socketChannel.socket.getSendBufferSize, sendBufferSize, socketChannel.socket.getReceiveBufferSize, recvBufferSize)) processor.accept(socketChannel) } catch { case e: TooManyConnectionsException => info("Rejected connection from %s, address already has the configured maximum of %d connections.".format(e.ip, e.count)) close(socketChannel) } } /** * Wakeup the thread for selection. */ @Override def wakeup = nioSelector.wakeup() } private[kafka] object Processor { val IdlePercentMetricName = "IdlePercent" val NetworkProcessorMetricTag = "networkProcessor" val ListenerMetricTag = "listener" } /** * Thread that processes all requests from a single connection. There are N of these running in parallel * each of which has its own selector */ private[kafka] class Processor(val id: Int, time: Time, maxRequestSize: Int, requestChannel: RequestChannel, connectionQuotas: ConnectionQuotas, connectionsMaxIdleMs: Long, listenerName: ListenerName, securityProtocol: SecurityProtocol, config: KafkaConfig, metrics: Metrics, credentialProvider: CredentialProvider, memoryPool: MemoryPool, logContext: LogContext) extends AbstractServerThread(connectionQuotas) with KafkaMetricsGroup { import Processor._ private object ConnectionId { def fromString(s: String): Option[ConnectionId] = s.split("-") match { case Array(local, remote, index) => BrokerEndPoint.parseHostPort(local).flatMap { case (localHost, localPort) => BrokerEndPoint.parseHostPort(remote).map { case (remoteHost, remotePort) => ConnectionId(localHost, localPort, remoteHost, remotePort, Integer.parseInt(index)) } } case _ => None } } private[network] case class ConnectionId(localHost: String, localPort: Int, remoteHost: String, remotePort: Int, index: Int) { override def toString: String = s"$localHost:$localPort-$remoteHost:$remotePort-$index" } private val newConnections = new ConcurrentLinkedQueue[SocketChannel]() private val inflightResponses = mutable.Map[String, RequestChannel.Response]() private val responseQueue = new LinkedBlockingDeque[RequestChannel.Response]() private[kafka] val metricTags = mutable.LinkedHashMap( ListenerMetricTag -> listenerName.value, NetworkProcessorMetricTag -> id.toString ).asJava newGauge(IdlePercentMetricName, new Gauge[Double] { def value = { Option(metrics.metric(metrics.metricName("io-wait-ratio", "socket-server-metrics", metricTags))).fold(0.0)(_.value) } }, // for compatibility, only add a networkProcessor tag to the Yammer Metrics alias (the equivalent Selector metric // also includes the listener name) Map(NetworkProcessorMetricTag -> id.toString) ) private val selector = createSelector( ChannelBuilders.serverChannelBuilder(listenerName, listenerName == config.interBrokerListenerName, securityProtocol, config, credentialProvider.credentialCache, credentialProvider.tokenCache)) // Visible to override for testing protected[network] def createSelector(channelBuilder: ChannelBuilder): KSelector = { channelBuilder match { case reconfigurable: Reconfigurable => config.addReconfigurable(reconfigurable) case _ => } new KSelector( maxRequestSize, connectionsMaxIdleMs, metrics, time, "socket-server", metricTags, false, true, channelBuilder, memoryPool, logContext) } // Connection ids have the format `localAddr:localPort-remoteAddr:remotePort-index`. The index is a // non-negative incrementing value that ensures that even if remotePort is reused after a connection is // closed, connection ids are not reused while requests from the closed connection are being processed. private var nextConnectionIndex = 0 override def run() { startupComplete() try { while (isRunning) { try { // setup any new connections that have been queued up configureNewConnections() // register any new responses for writing processNewResponses() poll() processCompletedReceives() processCompletedSends() processDisconnected() } catch { // We catch all the throwables here to prevent the processor thread from exiting. We do this because // letting a processor exit might cause a bigger impact on the broker. This behavior might need to be // reviewed if we see an exception that needs the entire broker to stop. Usually the exceptions thrown would // be either associated with a specific socket channel or a bad request. These exceptions are caught and // processed by the individual methods above which close the failing channel and continue processing other // channels. So this catch block should only ever see ControlThrowables. case e: Throwable => processException("Processor got uncaught exception.", e) } } } finally { debug("Closing selector - processor " + id) CoreUtils.swallow(closeAll(), this, Level.ERROR) shutdownComplete() } } private def processException(errorMessage: String, throwable: Throwable) { throwable match { case e: ControlThrowable => throw e case e => error(errorMessage, e) } } private def processChannelException(channelId: String, errorMessage: String, throwable: Throwable) { if (openOrClosingChannel(channelId).isDefined) { error(s"Closing socket for $channelId because of error", throwable) close(channelId) } processException(errorMessage, throwable) } private def processNewResponses() { var curr: RequestChannel.Response = null while ({curr = dequeueResponse(); curr != null}) { val channelId = curr.request.context.connectionId try { curr.responseAction match { case RequestChannel.NoOpAction => // There is no response to send to the client, we need to read more pipelined requests // that are sitting in the server's socket buffer updateRequestMetrics(curr) trace("Socket server received empty response to send, registering for read: " + curr) openOrClosingChannel(channelId).foreach(c => selector.unmute(c.id)) case RequestChannel.SendAction => val responseSend = curr.responseSend.getOrElse( throw new IllegalStateException(s"responseSend must be defined for SendAction, response: $curr")) sendResponse(curr, responseSend) case RequestChannel.CloseConnectionAction => updateRequestMetrics(curr) trace("Closing socket connection actively according to the response code.") close(channelId) } } catch { case e: Throwable => processChannelException(channelId, s"Exception while processing response for $channelId", e) } } } /* `protected` for test usage */ protected[network] def sendResponse(response: RequestChannel.Response, responseSend: Send) { val connectionId = response.request.context.connectionId trace(s"Socket server received response to send to $connectionId, registering for write and sending data: $response") // `channel` can be None if the connection was closed remotely or if selector closed it for being idle for too long if (channel(connectionId).isEmpty) { warn(s"Attempting to send response via channel for which there is no open connection, connection id $connectionId") response.request.updateRequestMetrics(0L, response) } // Invoke send for closingChannel as well so that the send is failed and the channel closed properly and // removed from the Selector after discarding any pending staged receives. // `openOrClosingChannel` can be None if the selector closed the connection because it was idle for too long if (openOrClosingChannel(connectionId).isDefined) { selector.send(responseSend) inflightResponses += (connectionId -> response) } } private def poll() { try selector.poll(300) catch { case e @ (_: IllegalStateException | _: IOException) => // The exception is not re-thrown and any completed sends/receives/connections/disconnections // from this poll will be processed. error(s"Processor $id poll failed", e) } } private def processCompletedReceives() { selector.completedReceives.asScala.foreach { receive => try { openOrClosingChannel(receive.source) match { case Some(channel) => val header = RequestHeader.parse(receive.payload) val context = new RequestContext(header, receive.source, channel.socketAddress, channel.principal, listenerName, securityProtocol) val req = new RequestChannel.Request(processor = id, context = context, startTimeNanos = time.nanoseconds, memoryPool, receive.payload, requestChannel.metrics) requestChannel.sendRequest(req) selector.mute(receive.source) case None => // This should never happen since completed receives are processed immediately after `poll()` throw new IllegalStateException(s"Channel ${receive.source} removed from selector before processing completed receive") } } catch { // note that even though we got an exception, we can assume that receive.source is valid. // Issues with constructing a valid receive object were handled earlier case e: Throwable => processChannelException(receive.source, s"Exception while processing request from ${receive.source}", e) } } } private def processCompletedSends() { selector.completedSends.asScala.foreach { send => try { val resp = inflightResponses.remove(send.destination).getOrElse { throw new IllegalStateException(s"Send for ${send.destination} completed, but not in `inflightResponses`") } updateRequestMetrics(resp) selector.unmute(send.destination) } catch { case e: Throwable => processChannelException(send.destination, s"Exception while processing completed send to ${send.destination}", e) } } } private def updateRequestMetrics(response: RequestChannel.Response) { val request = response.request val networkThreadTimeNanos = openOrClosingChannel(request.context.connectionId).fold(0L)(_.getAndResetNetworkThreadTimeNanos()) request.updateRequestMetrics(networkThreadTimeNanos, response) } private def processDisconnected() { selector.disconnected.keySet.asScala.foreach { connectionId => try { val remoteHost = ConnectionId.fromString(connectionId).getOrElse { throw new IllegalStateException(s"connectionId has unexpected format: $connectionId") }.remoteHost inflightResponses.remove(connectionId).foreach(updateRequestMetrics) // the channel has been closed by the selector but the quotas still need to be updated connectionQuotas.dec(InetAddress.getByName(remoteHost)) } catch { case e: Throwable => processException(s"Exception while processing disconnection of $connectionId", e) } } } /** * Close the connection identified by `connectionId` and decrement the connection count. * The channel will be immediately removed from the selector's `channels` or `closingChannels` * and no further disconnect notifications will be sent for this channel by the selector. * If responses are pending for the channel, they are dropped and metrics is updated. * If the channel has already been removed from selector, no action is taken. */ private def close(connectionId: String): Unit = { openOrClosingChannel(connectionId).foreach { channel => debug(s"Closing selector connection $connectionId") val address = channel.socketAddress if (address != null) connectionQuotas.dec(address) selector.close(connectionId) inflightResponses.remove(connectionId).foreach(response => updateRequestMetrics(response)) } } /** * Queue up a new connection for reading */ def accept(socketChannel: SocketChannel) { newConnections.add(socketChannel) wakeup() } /** * Register any new connections that have been queued up */ private def configureNewConnections() { while (!newConnections.isEmpty) { val channel = newConnections.poll() try { debug(s"Processor $id listening to new connection from ${channel.socket.getRemoteSocketAddress}") selector.register(connectionId(channel.socket), channel) } catch { // We explicitly catch all exceptions and close the socket to avoid a socket leak. case e: Throwable => val remoteAddress = channel.socket.getRemoteSocketAddress // need to close the channel here to avoid a socket leak. close(channel) processException(s"Processor $id closed connection from $remoteAddress", e) } } } /** * Close the selector and all open connections */ private def closeAll() { selector.channels.asScala.foreach { channel => close(channel.id) } selector.close() removeMetric(IdlePercentMetricName, Map(NetworkProcessorMetricTag -> id.toString)) } // 'protected` to allow override for testing protected[network] def connectionId(socket: Socket): String = { val localHost = socket.getLocalAddress.getHostAddress val localPort = socket.getLocalPort val remoteHost = socket.getInetAddress.getHostAddress val remotePort = socket.getPort val connId = ConnectionId(localHost, localPort, remoteHost, remotePort, nextConnectionIndex).toString nextConnectionIndex = if (nextConnectionIndex == Int.MaxValue) 0 else nextConnectionIndex + 1 connId } private[network] def enqueueResponse(response: RequestChannel.Response): Unit = { responseQueue.put(response) wakeup() } private def dequeueResponse(): RequestChannel.Response = { val response = responseQueue.poll() if (response != null) response.request.responseDequeueTimeNanos = Time.SYSTEM.nanoseconds response } private[network] def responseQueueSize = responseQueue.size // Only for testing private[network] def inflightResponseCount: Int = inflightResponses.size // Visible for testing // Only methods that are safe to call on a disconnected channel should be invoked on 'openOrClosingChannel'. private[network] def openOrClosingChannel(connectionId: String): Option[KafkaChannel] = Option(selector.channel(connectionId)).orElse(Option(selector.closingChannel(connectionId))) /* For test usage */ private[network] def channel(connectionId: String): Option[KafkaChannel] = Option(selector.channel(connectionId)) // Visible for testing private[network] def numStagedReceives(connectionId: String): Int = openOrClosingChannel(connectionId).map(c => selector.numStagedReceives(c)).getOrElse(0) /** * Wakeup the thread for selection. */ override def wakeup() = selector.wakeup() override def shutdown(): Unit = { super.shutdown() removeMetric("IdlePercent", Map("networkProcessor" -> id.toString)) } } class ConnectionQuotas(val defaultMax: Int, overrideQuotas: Map[String, Int]) { private val overrides = overrideQuotas.map { case (host, count) => (InetAddress.getByName(host), count) } private val counts = mutable.Map[InetAddress, Int]() def inc(address: InetAddress) { counts.synchronized { val count = counts.getOrElseUpdate(address, 0) counts.put(address, count + 1) val max = overrides.getOrElse(address, defaultMax) if (count >= max) throw new TooManyConnectionsException(address, max) } } def dec(address: InetAddress) { counts.synchronized { val count = counts.getOrElse(address, throw new IllegalArgumentException(s"Attempted to decrease connection count for address with no connections, address: $address")) if (count == 1) counts.remove(address) else counts.put(address, count - 1) } } def get(address: InetAddress): Int = counts.synchronized { counts.getOrElse(address, 0) } } class TooManyConnectionsException(val ip: InetAddress, val count: Int) extends KafkaException("Too many connections from %s (maximum = %d)".format(ip, count))
sebadiaz/kafka
core/src/main/scala/kafka/network/SocketServer.scala
Scala
apache-2.0
35,445
package leo.modules.output.logger import leo.modules.output.Output /** * Simple implementation of the [[Logging]] trait * with message logging to System.err (FD 1). * * The verbosity (logging level threshold) is set * by the `v` flag from the command-line arguments. * @see [[leo.Configuration]] */ object Out extends Logging { override protected val loggerName = "Console" override protected val useParentLoggers = false import java.util.logging.{ConsoleHandler, LogRecord, Formatter} addLogHandler( new ConsoleHandler { setLevel(defaultLogLevel) setFormatter(new Formatter { def format(record: LogRecord) = { val lines = record.getMessage.linesWithSeparators if (lines.hasNext) { val msg = lines.next() + lines.map(str => "% " + str).mkString("") s"% [${record.getLevel.getLocalizedName}] \\t $msg \\n" } else { "" } } }) override def publish(record: LogRecord): Unit = { super.publish(record) flush() } } ) def output(msg: Output): Unit = { println(msg.apply()) } def output(msg: String): Unit = { println(msg) } def comment(msg: String): Unit = {println(msg.linesWithSeparators.map(str => "% "+str).mkString(""))} }
lex-lex/Leo-III
src/main/scala/leo/modules/output/logger/Out.scala
Scala
bsd-3-clause
1,293
package dx.core.languages.wdl import wdlTools.types.{TypedAbstractSyntax => TAT, WdlTypes} case class Bundle(primaryCallable: Option[TAT.Callable], allCallables: Map[String, TAT.Callable], typeAliases: Map[String, WdlTypes.T])
dnanexus-rnd/dxWDL
src/main/scala/dx/core/languages/wdl/Bundle.scala
Scala
apache-2.0
265
package com.openquant.quoter.quotedb import org.specs2.specification.Scope import java.io.File trait TempDBScope extends Scope { val tmpPath = File.createTempFile("quoteDB_tests_", ".db") tmpPath.deleteOnExit() val quoteDB = QuoteDB(s"sqlite://$tmpPath") }
openquant/quoter
src/test/scala/com/larroy/quoter/quotedb/TempDBScope.scala
Scala
lgpl-3.0
265
/* * Accio is a platform to launch computer science experiments. * Copyright (C) 2016-2018 Vincent Primault <[email protected]> * * Accio is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Accio is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Accio. If not, see <http://www.gnu.org/licenses/>. */ package fr.cnrs.liris.util.reflect import scala.reflect.runtime.{universe => ru} // TODO: `tpe` should ultimately be private. final class ScalaType(val tpe: ru.Type) { /** * Return the associated JVM runtime class. */ lazy val runtimeClass: Class[_] = ReflectUtils.classForType(tpe) def isA[T: ru.TypeTag]: Boolean = tpe =:= ru.typeOf[T] def isLike[T: ru.TypeTag]: Boolean = tpe <:< ru.typeOf[T] def args: Seq[ScalaType] = tpe.typeArgs.map(new ScalaType(_)) def baseType[T: ru.TypeTag]: ScalaType = new ScalaType(tpe.baseType(ru.typeOf[T].typeSymbol)) /** * Return whether this field is an optional field. */ def isOption: Boolean = tpe <:< ScalaType.OPTION def isUnit: Boolean = tpe =:= ScalaType.UNIT override def toString: String = tpe.toString override def hashCode: Int = tpe.hashCode() override def equals(obj: scala.Any): Boolean = obj match { case scalaType: ScalaType => scalaType.tpe =:= tpe case _ => false } } object ScalaType { private[reflect] val OPTION = ru.typeOf[Option[_]] private[reflect] val UNIT = ru.typeOf[Unit] }
privamov/accio
accio/java/fr/cnrs/liris/util/reflect/ScalaType.scala
Scala
gpl-3.0
1,876
/******************************************************************************* Copyright (c) 2013, S-Core. All rights reserved. Use is subject to license terms. This distribution may include materials developed by third parties. ******************************************************************************/ package kr.ac.kaist.jsaf.analysis.typing.models import kr.ac.kaist.jsaf.analysis.typing.domain.PropValue sealed abstract class AbsProperty case class AbsBuiltinFunc(id: String, length: Double) extends AbsProperty case class AbsBuiltinFuncAftercall(id: String, length: Double) extends AbsProperty case class AbsBuiltinFuncCallback(id: String, length: Double) extends AbsProperty case class AbsInternalFunc(id: String) extends AbsProperty case class AbsConstValue(v: PropValue) extends AbsProperty
daejunpark/jsaf
src/kr/ac/kaist/jsaf/analysis/typing/models/AbsProperty.scala
Scala
bsd-3-clause
830
/* * sbt * Copyright 2011 - 2018, Lightbend, Inc. * Copyright 2008 - 2010, Mark Harrah * Licensed under Apache License 2.0 (see LICENSE) */ package testpkg import java.io.{ InputStream, OutputStream, PrintStream } import java.util.concurrent.{ LinkedBlockingQueue, TimeUnit, TimeoutException } import sbt.internal.client.NetworkClient import sbt.internal.util.Util import scala.collection.mutable object ClientTest extends AbstractServerTest { override val testDirectory: String = "client" object NullInputStream extends InputStream { override def read(): Int = { try this.synchronized(this.wait) catch { case _: InterruptedException => } -1 } } val NullPrintStream = new PrintStream(_ => {}, false) class CachingPrintStream extends { val cos = new CachingOutputStream } with PrintStream(cos, true) { def lines = cos.lines } class CachingOutputStream extends OutputStream { private val byteBuffer = new mutable.ArrayBuffer[Byte] override def write(i: Int) = Util.ignoreResult(byteBuffer += i.toByte) def lines = new String(byteBuffer.toArray, "UTF-8").linesIterator.toSeq } class FixedInputStream(keys: Char*) extends InputStream { var i = 0 override def read(): Int = { if (i < keys.length) { val res = keys(i).toInt i += 1 res } else -1 } } private[this] def background[R](f: => R): R = { val result = new LinkedBlockingQueue[R] val thread = new Thread("client-bg-thread") { setDaemon(true) start() override def run(): Unit = result.put(f) } result.poll(1, TimeUnit.MINUTES) match { case null => thread.interrupt() thread.join(5000) throw new TimeoutException case r => r } } private def client(args: String*): Int = { background( NetworkClient.client( testPath.toFile, args.toArray, NullInputStream, NullPrintStream, NullPrintStream, false ) ) } // This ensures that the completion command will send a tab that triggers // sbt to call definedTestNames or discoveredMainClasses if there hasn't // been a necessary compilation def tabs = new FixedInputStream('\\t', '\\t') private def complete(completionString: String): Seq[String] = { val cps = new CachingPrintStream background( NetworkClient.complete( testPath.toFile, Array(s"--completions=sbtn $completionString"), false, tabs, cps ) ) cps.lines } test("exit success") { c => assert(client("willSucceed") == 0) } test("exit failure") { _ => assert(client("willFail") == 1) } test("two commands") { _ => assert(client("compile;willSucceed") == 0) } test("two commands with failing second") { _ => assert(client("compile;willFail") == 1) } test("two commands with leading failure") { _ => assert(client("willFail;willSucceed") == 1) } test("three commands") { _ => assert(client("compile;clean;willSucceed") == 0) } test("three commands with middle failure") { _ => assert(client("compile;willFail;willSucceed") == 1) } test("compi completions") { _ => val expected = Vector( "compile", "compile:", "compileAnalysisFile", "compileAnalysisFilename", "compileAnalysisTargetRoot", "compileEarly", "compileIncSetup", "compileIncremental", "compileJava", "compileOrder", "compileOutputs", "compileProgress", "compileScalaBackend", "compileSplit", "compilerCache", "compilers", ) assert(complete("compi").toVector == expected) } test("testOnly completions") { _ => val testOnlyExpected = Vector( "testOnly", "testOnly/", "testOnly::", "testOnly;", ) assert(complete("testOnly") == testOnlyExpected) val testOnlyOptionsExpected = Vector("--", ";", "test.pkg.FooSpec") assert(complete("testOnly ") == testOnlyOptionsExpected) } test("quote with semi") { _ => assert(complete("\\"compile; fooB") == Vector("compile; fooBar")) } }
sbt/sbt
server-test/src/test/scala/testpkg/ClientTest.scala
Scala
apache-2.0
4,149
1 case class Values(ds: Double*) object MatchValues { def main(args: Array[String]) { val vals = Values(1.5, -2.3, 4.5) println(vals match { case Values(ds@_*) => /*start*/(0.0 /: ds)(_ + _)/*end*/ // wrong errors here }) } } //Double
ilinum/intellij-scala
testdata/typeInference/bugs5/SCL3123.scala
Scala
apache-2.0
259
case class i1() extends AnyRef
lampepfl/dotty
tests/pos/i5001.scala
Scala
apache-2.0
31
/** * Copyright (c) 2012 Petr Kozelek <[email protected]> * * The full copyright and license information is presented * in the file LICENSE that was distributed with this source code. */ package mql.model.semantic trait SqlExpression extends SqlConvertible
footcha/MQL
src/main/scala/mql/model/semantic/SqlExpression.scala
Scala
bsd-3-clause
267
package mesosphere.marathon import java.net.InetSocketAddress import java.util import com.google.inject.Module import com.twitter.common.quantity.{ Amount, Time } import com.twitter.common.zookeeper.ZooKeeperClient import mesosphere.chaos.App import mesosphere.chaos.http.{ HttpModule, HttpService } import mesosphere.chaos.metrics.MetricsModule import mesosphere.marathon.api.MarathonRestModule import mesosphere.marathon.core.CoreGuiceModule import mesosphere.marathon.event.EventModule import mesosphere.marathon.event.http.HttpEventModule import mesosphere.marathon.metrics.{ MetricsReporterModule, MetricsReporterService } import scala.concurrent.{ Future, Await } import org.apache.zookeeper.KeeperException import org.slf4j.LoggerFactory import scala.concurrent.duration._ import scala.collection.JavaConverters._ class MarathonApp extends App { val log = LoggerFactory.getLogger(getClass.getName) lazy val zk: ZooKeeperClient = { require( conf.zooKeeperSessionTimeout() < Integer.MAX_VALUE, "ZooKeeper timeout too large!" ) val client = new ZooKeeperLeaderElectionClient( Amount.of(conf.zooKeeperSessionTimeout().toInt, Time.MILLISECONDS), conf.zooKeeperHostAddresses.asJavaCollection ) // Marathon can't do anything useful without a ZK connection // so we wait to proceed until one is available var connectedToZk = false while (!connectedToZk) { try { log.info("Connecting to ZooKeeper...") client.get connectedToZk = true } catch { case t: Throwable => log.warn("Unable to connect to ZooKeeper, retrying...") } } client } def modules(): Seq[Module] = { Seq( new HttpModule(conf), new MetricsModule, new MetricsReporterModule(conf), new MarathonModule(conf, conf, zk), new MarathonRestModule, new EventModule(conf), new DebugModule(conf), new CoreGuiceModule ) ++ getEventsModule } def getEventsModule: Option[Module] = { conf.eventSubscriber.get.flatMap { case "http_callback" => log.info("Using HttpCallbackEventSubscriber for event notification") Some(new HttpEventModule(conf)) case _ => log.info("Event notification disabled.") None } } override lazy val conf = new AllConf(args) def runDefault(): Unit = { setConcurrentContextDefaults() log.info(s"Starting Marathon ${BuildInfo.version} with ${args.mkString(" ")}") run( classOf[HttpService], classOf[MarathonSchedulerService], classOf[MetricsReporterService] ) } /** * Make sure that we have more than one thread -- otherwise some unmarked blocking operations might cause trouble. * * See * [The Global Execution * Context](http://docs.scala-lang.org/overviews/core/futures.html#the-global-execution-context) * in the scala documentation. * * Here is the relevant excerpt in case the link gets broken: * * # The Global Execution Context * * ExecutionContext.global is an ExecutionContext backed by a ForkJoinPool. It should be sufficient for most * situations but requires some care. A ForkJoinPool manages a limited amount of threads (the maximum amount of * thread being referred to as parallelism level). The number of concurrently blocking computations can exceed the * parallelism level only if each blocking call is wrapped inside a blocking call (more on that below). Otherwise, * there is a risk that the thread pool in the global execution context is starved, and no computation can proceed. * * By default the ExecutionContext.global sets the parallelism level of its underlying fork-join pool to the amount * of available processors (Runtime.availableProcessors). This configuration can be overriden by setting one * (or more) of the following VM attributes: * * scala.concurrent.context.minThreads - defaults to Runtime.availableProcessors * scala.concurrent.context.numThreads - can be a number or a multiplier (N) in the form ‘xN’ ; * defaults to Runtime.availableProcessors * scala.concurrent.context.maxThreads - defaults to Runtime.availableProcessors * * The parallelism level will be set to numThreads as long as it remains within [minThreads; maxThreads]. * * As stated above the ForkJoinPool can increase the amount of threads beyond its parallelismLevel in the * presence of blocking computation. */ private[this] def setConcurrentContextDefaults(): Unit = { def setIfNotDefined(property: String, value: String): Unit = { if (!sys.props.contains(property)) { sys.props += property -> value } } setIfNotDefined("scala.concurrent.context.minThreads", "5") setIfNotDefined("scala.concurrent.context.numThreads", "x2") setIfNotDefined("scala.concurrent.context.maxThreads", "64") } class ZooKeeperLeaderElectionClient(sessionTimeout: Amount[Integer, Time], zooKeeperServers: java.lang.Iterable[InetSocketAddress]) extends ZooKeeperClient(sessionTimeout, zooKeeperServers) { override def shouldRetry(e: KeeperException): Boolean = { log.error("Got ZooKeeper exception", e) log.error("Committing suicide to avoid invalidating ZooKeeper state") val f = Future { // scalastyle:off magic.number Runtime.getRuntime.exit(9) // scalastyle:on }(scala.concurrent.ExecutionContext.global) try { Await.result(f, 5.seconds) } catch { case _: Throwable => log.error("Finalization failed, killing JVM.") // scalastyle:off magic.number Runtime.getRuntime.halt(1) // scalastyle:on } false } } } object Main extends MarathonApp { runDefault() }
ss75710541/marathon
src/main/scala/mesosphere/marathon/Main.scala
Scala
apache-2.0
5,929
package org.jetbrains.plugins.scala package lang package psi package stubs package elements import com.intellij.lang.ASTNode import com.intellij.psi.PsiElement import com.intellij.psi.stubs.{IndexSink, StubElement, StubInputStream, StubOutputStream} import com.intellij.util.io.StringRef._ import org.jetbrains.plugins.scala.lang.psi.api.toplevel.ScPackaging import org.jetbrains.plugins.scala.lang.psi.impl.toplevel.packaging.ScPackagingImpl import org.jetbrains.plugins.scala.lang.psi.stubs.impl.ScPackagingStubImpl import org.jetbrains.plugins.scala.lang.psi.stubs.index.ScalaIndexKeys import org.jetbrains.plugins.scala.lang.refactoring.util.ScalaNamesUtil /** * @author ilyas */ class ScPackagingElementType extends ScStubElementType[ScPackagingStub, ScPackaging]("packaging") { override def serialize(stub: ScPackagingStub, dataStream: StubOutputStream): Unit = { dataStream.writeName(stub.parentPackageName) dataStream.writeName(stub.packageName) dataStream.writeBoolean(stub.isExplicit) } override def deserialize(dataStream: StubInputStream, parentStub: StubElement[_ <: PsiElement]): ScPackagingStub = new ScPackagingStubImpl(parentStub.asInstanceOf[StubElement[PsiElement]], this, parentPackageNameRef = dataStream.readName, packageNameRef = dataStream.readName, isExplicit = dataStream.readBoolean) override def createStub(packaging: ScPackaging, parentStub: StubElement[_ <: PsiElement]): ScPackagingStub = new ScPackagingStubImpl(parentStub, this, parentPackageNameRef = fromString(packaging.parentPackageName), packageNameRef = fromString(packaging.packageName), isExplicit = packaging.isExplicit) override def indexStub(stub: ScPackagingStub, sink: IndexSink): Unit = { val prefix = stub.parentPackageName var ownNamePart = stub.packageName def append(postfix: String) = ScalaNamesUtil.cleanFqn(if (prefix.length > 0) prefix + "." + postfix else postfix) var i = 0 do { sink.occurrence[ScPackaging, java.lang.Integer](ScalaIndexKeys.PACKAGE_FQN_KEY, append(ownNamePart).hashCode) i = ownNamePart.lastIndexOf(".") if (i > 0) { ownNamePart = ownNamePart.substring(0, i) } } while (i > 0) } override def createElement(node: ASTNode): ScPackaging = new ScPackagingImpl(node) override def createPsi(stub: ScPackagingStub): ScPackaging = new ScPackagingImpl(stub) }
ilinum/intellij-scala
src/org/jetbrains/plugins/scala/lang/psi/stubs/elements/ScPackagingElementType.scala
Scala
apache-2.0
2,424