Merge branch 'wip-camel-irc' of github.com:bwmcadams/scalgore into wi…

…p-camel-irc

Conflicts:
	project/build/ScalGore.scala

.gitignore

@@ -1,3 +1,5 @@
 target
 lib_managed
 project/boot
+project/plugins/src_managed
+project/plugins/project

project/build/ScalGore.scala

@@ -1,19 +1,25 @@
 import sbt._
 
-class ScalGoreProject(info: ProjectInfo) extends DefaultProject(info) {
+class ScalGoreProject(info: ProjectInfo) extends DefaultProject(info) with AkkaProject {
   override val mainClass = Some("net.evilmonkeylabs.scalgore.ScalGore")
 
+  val TwitterRepo = MavenRepository("Twitter Repository", "http://maven.twttr.com")
+  val MavenLocal = MavenRepository("Local Maven Repository", "file://" + Path.userHome + "/.m2/repository")
+  val SonatypeReleasesRepo = MavenRepository("Sonatype OSS Repo", "http://oss.sonatype.org/content/repositories/releases")
+
+
+  val configgyConfig = ModuleConfiguration("net.lag", "configgy", "2.0.2", TwitterRepo)
+  val elasticConfig = ModuleConfiguration("org.elasticsearch", SonatypeReleasesRepo)
+
   val elasticSearch = "org.elasticsearch" % "elasticsearch" % "0.16.3"
   val commonsHTTP = "commons-httpclient" % "commons-httpclient" % "3.1"
 
   val casbah = "com.mongodb.casbah" %% "casbah" % "2.1.5-1"
   val akka_actor = "se.scalablesolutions.akka" % "akka-actor" % "1.0"
+  val akka_camel = akkaModule("camel")
+  val camel_irc = "org.apache.camel" % "camel-irc" % "2.5.0"
   val configgy = "net.lag" % "configgy" % "2.0.2"
 
-  val twitterRep = "Twitter" at "http://maven.twttr.com"
-  val sonaRepo = "Sona Repo" at "http://oss.sonatype.org/content/repositories/releases/"
-  val akkaRepo = "Akka Repository" at "http://www.akka.io/repository"
-  val mavenLocal = "Local Maven Repository" at "file://" + Path.userHome + "/.m2/repository"
 }
 
 // vim: set ts=2 sw=2 sts=2 et:

project/plugins/Plugins.scala

@@ -0,0 +1,7 @@
+import sbt._
+
+class Plugins(info: ProjectInfo) extends PluginDefinition(info) {
+  lazy val akkaRepo = "Akka Repository" at "http://akka.io/repository"
+
+  lazy val akkaPlugin = "se.scalablesolutions.akka" % "akka-sbt-plugin" % "1.0"
+}

src/main/resources/akka.conf

@@ -0,0 +1,3 @@
+akka {
+ enabled-modules = [ "camel" ] 
+}

src/main/resources/scalgore.conf

@@ -1,12 +1,11 @@
 scalgore {
 
-	nick = "scalgore"
+	networks = [ "freenode"]
 
-	servers = [ "freenode"]
-
-	freenode {		
-		uri = "irc.freenode.net"
-		channels = [ "#scalgore", "#akka" ]
+	freenode {
+	  nick = "scalgore"
+		host = "irc.freenode.net"
+		channels = [ "#scalgore" ]
 	}
 
 }

src/main/scala/IrcConsumer.scala

@@ -0,0 +1,27 @@
+package net.evilmonkeylabs.scalgore
+
+import net.lag.configgy.Configgy
+import akka.actor.{Actor, ActorRef}
+import akka.util._
+import akka.camel._
+
+class IrcConsumer(network: Network, ircLog: ActorRef) extends Actor with Consumer with Logging {
+
+  lazy val _endpointUri = "irc:%s@%s?channels=%s" format (network.nick, network.host, network.channels.mkString(","))
+
+  def endpointUri = _endpointUri
+
+  def receive = {
+    case Message(body: String, headers: Map[String, String]) => {
+      for ( sender <- headers.get("irc.user.nick");
+              host <- headers.get("irc.user.host");
+             login <- headers.get("irc.user.username");
+           channel <- headers.get("irc.target");
+           msgtype <- headers.get("irc.messageType") if msgtype == "PRIVMSG") {
+        ircLog ! IrcPublicMessage(network.name, channel, sender, login, host, body)
+      } // for
+    } // case
+  } // receive
+}
+
+// vim: set ts=2 sw=2 sts=2 et:

src/main/scala/IrcLogger.scala

@@ -5,7 +5,6 @@
  */
 package net.evilmonkeylabs.scalgore
 
-import org.jibble.pircbot._
 import akka.actor._
 import akka.util._
 import com.mongodb.casbah.Imports._
@@ -22,19 +21,22 @@ trait IrcMessage {
   val date = new java.util.Date // capture date as soon as object is created
 }
 
-case class IrcAction(val sender: String,
+case class IrcAction(val network: String,
+                     val sender: String,
                      val login: String,
                      val hostname: String,
                      val message: String,
                      val target: String) extends IrcMessage
 
-case class IrcPublicMessage(val channel: String,
+case class IrcPublicMessage(val network: String,
+                            val channel: String,
                             val sender: String,
                             val login: String,
                             val hostname: String,
                             val message: String) extends IrcMessage
 
-case class IrcPrivateMessage(val sender: String,
+case class IrcPrivateMessage(val network: String,
+                             val sender: String,
                              val login: String,
                              val hostname: String,
                              val message: String) extends IrcMessage
@@ -45,11 +47,11 @@ class IrcLogger extends Actor with Logging {
   // val es = new TransportClient().addTransportAddress(new InetSocketTransportAddress("localhost", 9300))
 
   def parseMessage(msg: String) = msg.split(" ")
-  def fixChanName(name: String) = name.replaceAll("#", "HASH")
+  def fixChanName(network: String, name: String) = network ++ name.replaceAll("#", "HASH")
 
   def receive = {
-    case pub @ IrcPublicMessage(channel, sender, login, hostname, message) => {
-      val name = fixChanName(channel)
+    case pub @ IrcPublicMessage(network, channel, sender, login, hostname, message) => {
+      val name = fixChanName(network, channel)
       val kws = parseMessage(message)
       val idx = MongoDBObject("sender" -> 1, "keywords" -> 1)
       mongo(name).ensureIndex(idx)
@@ -61,13 +63,13 @@ class IrcLogger extends Actor with Logging {
       //                      .source(obj.toString)).actionGet()
       mongo(name) += (obj)
     }
-    case priv @ IrcPrivateMessage(sender, login, hostname, message) => {
+    case priv @ IrcPrivateMessage(network, sender, login, hostname, message) => {
       val obj = MongoDBObject("type" -> "privateMessage", "sender" -> sender, "login" -> login,
                  "hostname" -> hostname, "message" -> message)
       //mongo("privateMessages") insert(obj) 
     }
-    case act @ IrcAction(sender, login, hostname, message, target) => {
-      val name = fixChanName(target)
+    case act @ IrcAction(network, sender, login, hostname, message, target) => {
+      val name = fixChanName(network, target)
       val kws = parseMessage(message)
       val obj = MongoDBObject("type" -> "action", "target" -> target, "sender" -> sender, "login" -> login,
                  "hostname" -> hostname, "message" -> message, "keywords" -> kws, "date" -> act.date)

src/main/scala/ScalGore.scala

@@ -5,36 +5,45 @@
  */
 package net.evilmonkeylabs.scalgore
 
-import org.jibble.pircbot._
-import net.lag.configgy.Configgy
+import net.lag.configgy.{Config=>CConfig}
 import akka.actor._
+import Actor._
+import akka.config.Supervision._
 import akka.util._
+import akka.camel._
 
 object Config {
-	val servers = "scalgore.servers"
+	val networks = "scalgore.networks"
 
-	val uri: (String)=>String = "scalgore.%s.uri" format _
+	val host: (String)=>String = "scalgore.%s.host" format _
 	val channels: (String)=>String = "scalgore.%s.channels" format _
+	val nick: (String)=>String = "scalgore.%s.nick" format _
 }
 
-case class Connection(name: String, uri: String, channels: Seq[String])
+case class Network(name: String, host: String, nick: String, channels: Seq[String])
 
 object ScalGore extends Logging {
 
   def main(args: Array[String]) {
-  	Configgy.configureFromResource("scalgore.conf", getClass.getClassLoader)
-    val bot = new IrcBot("ScalGore", true)
+    val cfg = CConfig.fromResource("scalgore.conf", getClass.getClassLoader)
 
-    val cfg = Configgy.config
+    CamelServiceManager.startCamelService
 
+    val irclog = actorOf[IrcLogger].start
 
+    val consumers =
+      for (name <- cfg.getList(Config.networks);
+           host <- cfg.getString(Config.host(name));
+           nick <- cfg.getString(Config.nick(name)))
+        yield actorOf(new IrcConsumer(Network(name, host, nick, cfg.getList(Config.channels(name))), irclog))
 
-    for (s <- cfg.getList(Config.servers);
-    	 uri <- cfg.getString(Config.uri(s))) {
-      log.info("lala")
-      val conn = Connection(s, uri, cfg.getList(Config.channels(s)))
-      bot.join(conn)
-   	}
+    val supervisor = Supervisor(
+      SupervisorConfig(
+        OneForOneStrategy(List(classOf[Exception]), 3, 10),
+        Supervise(irclog, Permanent) +:
+        consumers.map { a => Supervise(a, Permanent) }.toList))
+
+    supervisor.start
   }
 }