Pourquoi ne pas résoudre sbt-akka-remote?

Question

Quand je Générez et exécutez ce programme sur SBT il a des erreurs suivantes:

[info] Updating {file:/opt/ifkaar/akkaprojects/calculation/}calculation... 
[info] Resolving com.typesafe.akka#akka-remote;2.3.4 ... 
[warn] module not found: com.typesafe.akka#akka-remote;2.3.4 
[warn] ==== local: tried 
[warn] /home/sarawaheed/.ivy2/local/com.typesafe.akka/akka-remote/2.3.4/ivys/ivy.xml 
[warn] ==== public: tried 
[warn] http://repo1.maven.org/maven2/com/typesafe/akka/akka-remote/2.3.4/akka-remote-2.3.4.pom 
[warn] ==== Typesafe Repository: tried 
[warn] http://repo.typesafe.com/typesafe/releases/com/typesafe/akka/akka-remote/2.3.4/akka-remote-2.3.4.pom 
[info] Resolving jline#jline;2.11 ... 
[warn] :::::::::::::::::::::::::::::::::::::::::::::: 
[warn] ::   UNRESOLVED DEPENDENCIES   :: 
[warn] :::::::::::::::::::::::::::::::::::::::::::::: 
[warn] :: com.typesafe.akka#akka-remote;2.3.4: not found 
[warn] :::::::::::::::::::::::::::::::::::::::::::::: 
[trace] Stack trace suppressed: run last *:update for the full output. 
[error] (*:update) sbt.ResolveException: unresolved dependency: com.typesafe.akka#akka-remote;2.3.4: not found 
[error] Total time: 2 s, completed Jul 17, 2014 3:38:42 PM 

Voici mon fichier build.sbt

name := "calculation" 

version := "1.0" 

scalaVersion := "2.11.1" 

resolvers += "Typesafe Repository" at "http://repo.typesafe.com/typesafe/releases/" 

libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.3.4,"com.typesafe.akka" %% "akka-remote" % "2.3.4"" 

voici mon code PI.scala

import akka.actor._ 
import akka.routing.RoundRobinRouter 
import akka.util.Duration 
import akka.util.duration._ 

object Pi extends App { 

calculate(nrOfWorkers = 4, nrOfElements = 10000, nrOfMessages = 10000) 

sealed trait PiMessage 
case object Calculate extends PiMessage 
case class Work(start: Int, nrOfElements: Int) extends PiMessage 
case class Result(value: Double) extends PiMessage 
case class PiApproximation(pi: Double, duration: Duration) 

class Worker extends Actor { 

def calculatePiFor(start: Int, nrOfElements: Int): Double = { 
var acc = 0.0 
for (i ← start until (start + nrOfElements)) 
acc += 4.0 * (1 - (i % 2) * 2)/(2 * i + 1) 
acc 
} 

def receive = { 
case Work(start, nrOfElements) ⇒ 
sender ! Result(calculatePiFor(start, nrOfElements)) // perform the work 
} 
} 

class Master(nrOfWorkers: Int, nrOfMessages: Int, nrOfElements: Int, listener: ActorRef) 
extends Actor { 

var pi: Double = _ 
var nrOfResults: Int = _ 
val start: Long = System.currentTimeMillis 

val workerRouter = context.actorOf(
Props[Worker].withRouter(RoundRobinRouter(nrOfWorkers)), name = "workerRouter") 

def receive = { 
case Calculate ⇒ 
for (i ← 0 until nrOfMessages) workerRouter ! Work(i * nrOfElements, nrOfElements) 
case Result(value) ⇒ 
pi += value 
nrOfResults += 1 
if (nrOfResults == nrOfMessages) { 
// Send the result to the listener 
listener ! PiApproximation(pi, duration = (System.currentTimeMillis - start).millis) 
// Stops this actor and all its supervised children 
context.stop(self) 
} 
} 

} 

class Listener extends Actor { 
def receive = { 
case PiApproximation(pi, duration) ⇒ 
println("\n\tPi approximation: \t\t%s\n\tCalculation time: \t%s" 
.format(pi, duration)) 
context.system.shutdown() 
} 
} 


def calculate(nrOfWorkers: Int, nrOfElements: Int, nrOfMessages: Int) { 
// Create an Akka system 
val system = ActorSystem("PiSystem") 

// create the result listener, which will print the result and shutdown the system 
val listener = system.actorOf(Props[Listener], name = "listener") 

// create the master 
val master = system.actorOf(Props(new Master(
nrOfWorkers, nrOfMessages, nrOfElements, listener)), 
name = "master") 

// start the calculation 
master ! Calculate 

} 
} 

Note: Je suis this tutoriel.

Answer 1

L'entrée libraryDependencies dans votre fichier build.sbt devrait ressembler à ceci:

libraryDependencies ++= Seq(
    "com.typesafe.akka" %% "akka-actor" % "2.3.4", 
    "com.typesafe.akka" %% "akka-remote" % "2.3.4" 
) 

L'opérateur ++= est une sorte d'opérateur de concaténation de liste. Il dit à sbt de fusionner cette nouvelle collection de dépendances avec celles existantes, quelle qu'elle soit.

L'opérateur += ajoute un seul élément, par opposition à la concaténation d'une collection. Par exemple:

libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.3.4" 

libraryDependencies += "com.typesafe.akka" %% "akka-remote" % "2.3.4" 

L'opérateur %% est un raccourci pour spécifier explicitement la version Scala que les bibliothèques nécessaires doivent être compilés. Il existe un nom de bibliothèque différent pour chaque version de Scala. Par exemple, au lieu d'écrire:

"com.typesafe.akka" % "akka-actor_2.11" % "2.3.4" 

Vous écrivez:

"com.typesafe.akka" %% "akka-actor" % "2.3.4" 

Le paramètre déclaré scalaVersion sera utilisé pour "développer" l'opérateur %%. Notez que seuls les numéros X.Y de la version complète X.Y.Z seront utilisés. Cela arrive parce que les versions de Scala sont compatibles quand Z change, mais pas quand X ou Y change.

Vous pouvez aussi finir par se retrouver avec les éléments suivants pour éviter les duplications:

libraryDependencies ++= Seq("actor", "remote").map("akka-" + _).map("com.typesafe.akka" %% _ % "2.3.4") 

Et depuis akka-remote dépend de akka-actor les suffixes suivants:

libraryDependencies += "com.typesafe.akka" %% "akka-remote" % "2.3.4"