├── .gitignore
├── LICENSE
├── README.md
├── activator.properties
├── build.sbt
├── project
    └── build.properties
├── src
    ├── main
    │   └── scala
    │   │   └── com
    │   │       └── example
    │   │           ├── PingActor.scala
    │   │           ├── PongActor.scala
    │   │           ├── consumer
    │   │               ├── BatchCommittableSourceConsumerMain.scala
    │   │               ├── CommittableSourceConsumerMain.scala
    │   │               └── PlainSourceConsumerMain.scala
    │   │           └── producer
    │   │               ├── CommitConsumerToFlowProducerMain.scala
    │   │               ├── ConsumerToCommitableSinkProducerMain.scala
    │   │               ├── FlowProducerMain.scala
    │   │               └── PlainSinkProducerMain.scala
    └── test
    │   └── scala
    │       └── com
    │           └── example
    │               └── PingPongActorSpec.scala
└── tutorial
    ├── index.html
    └── index.md


/.gitignore:
--------------------------------------------------------------------------------
 1 | 
 2 | # Created by https://www.gitignore.io/api/scala
 3 | 
 4 | ### Scala ###
 5 | *.class
 6 | *.log
 7 | 
 8 | # sbt specific
 9 | .cache
10 | .history
11 | .lib/
12 | dist/*
13 | target/
14 | lib_managed/
15 | src_managed/
16 | project/boot/
17 | project/plugins/project/
18 | 
19 | # Scala-IDE specific
20 | .scala_dependencies
21 | .worksheet
22 | 
23 | /.idea
24 | 
25 | # ENSIME specific
26 | .ensime_cache/
27 | .ensime
28 | .idea/libraries/SBT__org_scala_lang_modules_scala_xml_2_11_1_0_5_jar.xml
29 | .idea/libraries/SBT__org_scala_lang_scala_reflect_2_11_8_jar.xml
30 | .idea/libraries/SBT__org_scalactic_scalactic_2_11_3_0_0_jar.xml
31 | .idea/libraries/SBT__org_scalatest_scalatest_2_11_3_0_0_jar.xml
32 | .idea/modules/reactive-kafka-example0830-build.iml
33 | .idea/modules/reactive-kafka-example0830.iml
34 | .idea/vcs.xml
35 | 
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright 2014 Typesafe, Inc.
 2 | 
 3 | Licensed under the Apache License, Version 2.0 (the "License");
 4 | you may not use this file except in compliance with the License.
 5 | You may obtain a copy of the License at
 6 | 
 7 | http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | reactive-kafka-scala-example
 2 | =========================
 3 | reactive-kafka examples in scala
 4 | 
 5 | Akka Streams Kafka: http://doc.akka.io/docs/akka-stream-kafka/current/home.html
 6 | 
 7 | ### Install Kafka on OSX
 8 | ```
 9 | brew install kafka
10 | ```
11 | 
12 | ### Start Kafka
13 | ```
14 | zkserver start
15 | kafka-server-start /usr/local/etc/kafka/server.properties
16 | ```
17 | 
18 | ### Start a consumer on console for topic1/topic2
19 | ```
20 | kafka-console-consumer --zookeeper localhost:2181 --topic topic1  --from-beginning
21 | kafka-console-consumer --zookeeper localhost:2181 --topic topic2  --from-beginning
22 | ```
23 | 
24 | ### Start a producer on console for topic1
25 | ```
26 | kafka-console-producer --broker-list localhost:9092 --topic topic1
27 | ```
28 | ===
29 | ### Start reactive-kafka examples
30 | ```
31 | git clone https://github.com/makersu/reactive-kafka-scala-example.git
32 | cd reactive-kafka-scala-example
33 | sbt run
34 | ```
35 | ```
36 | Multiple main classes detected, select one to run:
37 | 
38 |  [1] com.example.consumer.BatchCommittableSourceConsumerMain
39 |  [2] com.example.consumer.CommittableSourceConsumerMain
40 |  [3] com.example.consumer.PlainSourceConsumerMain
41 |  [4] com.example.producer.CommitConsumerToFlowProducerMain
42 |  [5] com.example.producer.ConsumerToCommitableSinkProducerMain
43 |  [6] com.example.producer.FlowProducerMain
44 |  [7] com.example.producer.PlainSinkProducerMain
45 | 
46 | Enter number:
47 | ```
48 | 
49 | 
50 | 
51 | 


--------------------------------------------------------------------------------
/activator.properties:
--------------------------------------------------------------------------------
1 | name=reactive-kafka-scala-example
2 | title=Apahce Kafka examples using reactive-kafka in scala
3 | description=Apache Kafka examples using reactive-kafka in scala.
4 | tags=kafka,reactive-kafka,akka-stream,scala,producer,consumer
5 | 


--------------------------------------------------------------------------------
/build.sbt:
--------------------------------------------------------------------------------
 1 | name := """reactive-kafka-example"""
 2 | 
 3 | version := "1.0"
 4 | 
 5 | scalaVersion := "2.11.8"
 6 | 
 7 | val akkaVersion = "2.4.9"
 8 | 
 9 | libraryDependencies ++= Seq(
10 |   "com.typesafe.akka" %% "akka-actor" % akkaVersion,
11 |   "com.typesafe.akka" %% "akka-testkit" % akkaVersion % "test",
12 |   "org.scalatest" %% "scalatest" % "3.0.0" % "test")
13 | 
14 | libraryDependencies ++= Seq(
15 |   "com.typesafe.akka" %% "akka-stream-kafka" % "0.11-RC1"
16 | )
17 | 
18 | 


--------------------------------------------------------------------------------
/project/build.properties:
--------------------------------------------------------------------------------
1 | #Activator-generated Properties
2 | #Wed Aug 31 11:50:59 CST 2016
3 | template.uuid=c331da07-ace3-45a5-bc6d-bf11e5d6385c
4 | sbt.version=0.13.8
5 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/PingActor.scala:
--------------------------------------------------------------------------------
 1 | package com.example
 2 | 
 3 | import akka.actor.{Actor, ActorLogging, Props}
 4 | 
 5 | class PingActor extends Actor with ActorLogging {
 6 |   import PingActor._
 7 |   
 8 |   var counter = 0
 9 |   val pongActor = context.actorOf(PongActor.props, "pongActor")
10 | 
11 |   def receive = {
12 |   	case Initialize => 
13 | 	    log.info("In PingActor - starting ping-pong")
14 |   	  pongActor ! PingMessage("ping")	
15 |   	case PongActor.PongMessage(text) =>
16 |   	  log.info("In PingActor - received message: {}", text)
17 |   	  counter += 1
18 |   	  if (counter == 3) context.system.shutdown()
19 |   	  else sender() ! PingMessage("ping")
20 |   }	
21 | }
22 | 
23 | object PingActor {
24 |   val props = Props[PingActor]
25 |   case object Initialize
26 |   case class PingMessage(text: String)
27 | }


--------------------------------------------------------------------------------
/src/main/scala/com/example/PongActor.scala:
--------------------------------------------------------------------------------
 1 | package com.example
 2 | 
 3 | import akka.actor.{Actor, ActorLogging, Props}
 4 | 
 5 | class PongActor extends Actor with ActorLogging {
 6 |   import PongActor._
 7 | 
 8 |   def receive = {
 9 |   	case PingActor.PingMessage(text) => 
10 |   	  log.info("In PongActor - received message: {}", text)
11 |   	  sender() ! PongMessage("pong")
12 |   }	
13 | }
14 | 
15 | object PongActor {
16 |   val props = Props[PongActor]
17 |   case class PongMessage(text: String)
18 | }
19 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/consumer/BatchCommittableSourceConsumerMain.scala:
--------------------------------------------------------------------------------
 1 | package com.example.consumer
 2 | 
 3 | import akka.Done
 4 | import akka.actor.ActorSystem
 5 | import akka.kafka.ConsumerMessage.CommittableOffsetBatch
 6 | import akka.kafka.scaladsl.Consumer
 7 | import akka.kafka.{ConsumerSettings, Subscriptions}
 8 | import akka.stream.ActorMaterializer
 9 | import akka.stream.scaladsl.Sink
10 | import org.apache.kafka.clients.consumer.ConsumerConfig
11 | import org.apache.kafka.common.serialization.{ByteArrayDeserializer, StringDeserializer}
12 | 
13 | import scala.concurrent.ExecutionContext.Implicits.global
14 | import scala.concurrent.Future
15 | /**
16 |   * Created by marksu on 8/31/16.
17 |   */
18 | object BatchCommittableSourceConsumerMain extends App {
19 |   implicit val system = ActorSystem("BatchCommittableSourceConsumerMain")
20 |   implicit val materializer = ActorMaterializer()
21 | 
22 |   //TODO: move to configuration application.conf
23 |   val consumerSettings = ConsumerSettings(system, new ByteArrayDeserializer, new StringDeserializer)
24 |     .withBootstrapServers("localhost:9092")
25 |     .withGroupId("BatchCommittableSourceConsumer")
26 |     .withProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest")
27 | 
28 |   val done =
29 |     Consumer.committableSource(consumerSettings, Subscriptions.topics("topic1"))
30 |       .mapAsync(1) { msg =>
31 |         println(s"BatchCommittableConsumer consume: $msg")
32 |         Future.successful(Done).map(_ => msg.committableOffset)
33 |       }
34 |       .batch(max = 20, first => CommittableOffsetBatch.empty.updated(first)) { (batch, elem) =>
35 |         batch.updated(elem)
36 |       }
37 |       .mapAsync(3)(_.commitScaladsl())
38 |       .runWith(Sink.ignore)
39 | 
40 | }
41 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/consumer/CommittableSourceConsumerMain.scala:
--------------------------------------------------------------------------------
 1 | package com.example.consumer
 2 | 
 3 | import akka.actor.ActorSystem
 4 | import akka.kafka.scaladsl.Consumer
 5 | import akka.kafka.{ConsumerSettings, Subscriptions}
 6 | import akka.stream.ActorMaterializer
 7 | import akka.stream.scaladsl.Sink
 8 | import org.apache.kafka.clients.consumer.ConsumerConfig
 9 | import org.apache.kafka.common.serialization.{ByteArrayDeserializer, StringDeserializer}
10 | 
11 | /**
12 |   * Created by marksu on 8/31/16.
13 |   */
14 | object CommittableSourceConsumerMain extends App {
15 | 
16 |   implicit val system = ActorSystem("CommittableSourceConsumerMain")
17 |   implicit val materializer = ActorMaterializer()
18 | 
19 |   //TODO: move to configuration application.conf
20 |   val consumerSettings =
21 |     ConsumerSettings(system, new ByteArrayDeserializer, new StringDeserializer)
22 |       .withBootstrapServers("localhost:9092")
23 |       .withGroupId("CommittableSourceConsumer")
24 |       .withProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest")
25 | 
26 |   val done =
27 |     Consumer.committableSource(consumerSettings, Subscriptions.topics("topic1"))
28 |       .mapAsync(1) { msg =>
29 |         println(s"CommittableSourceConsumer consume: $msg")
30 |         msg.committableOffset.commitScaladsl()
31 |       }
32 |       .runWith(Sink.ignore)
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/consumer/PlainSourceConsumerMain.scala:
--------------------------------------------------------------------------------
 1 | package com.example.consumer
 2 | 
 3 | import java.util.concurrent.atomic.AtomicLong
 4 | 
 5 | import akka.Done
 6 | import akka.actor.ActorSystem
 7 | import akka.kafka.scaladsl.Consumer
 8 | import akka.kafka.{ConsumerSettings, Subscriptions}
 9 | import akka.stream.ActorMaterializer
10 | import akka.stream.scaladsl.Sink
11 | import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
12 | import org.apache.kafka.common.TopicPartition
13 | import org.apache.kafka.common.serialization.{ByteArrayDeserializer, StringDeserializer}
14 | 
15 | import scala.concurrent.ExecutionContext.Implicits.global
16 | import scala.concurrent.Future
17 | 
18 | /**
19 |   * Created by marksu on 8/31/16.
20 |   */
21 | object PlainSourceConsumerMain extends App {
22 |   implicit val system = ActorSystem("PlainSourceConsumerMain")
23 |   implicit val materializer = ActorMaterializer()
24 | 
25 |   //TODO: move to configuration application.conf
26 |   val consumerSettings = ConsumerSettings(system, new ByteArrayDeserializer, new StringDeserializer)
27 |     .withBootstrapServers("localhost:9092")
28 |     .withGroupId("PlainSourceConsumer")
29 |     .withProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest")
30 | 
31 |   val db = new DB
32 |   db.loadOffset().foreach { fromOffset =>
33 |     val partition = 0
34 |     val subscription = Subscriptions.assignmentWithOffset(
35 |       new TopicPartition("topic1", partition) -> fromOffset
36 |     )
37 |     val done =
38 |       Consumer.plainSource(consumerSettings, subscription)
39 |         .mapAsync(1)(db.save)
40 |         .runWith(Sink.ignore)
41 |   }
42 | 
43 | }
44 | 
45 | //External Offset Storage
46 | class DB {
47 | 
48 |   private val offset = new AtomicLong(2)
49 | 
50 |   def save(record: ConsumerRecord[Array[Byte], String]): Future[Done] = {
51 |     println(s"DB.save: ${record.value}")
52 |     offset.set(record.offset)
53 |     Future.successful(Done)
54 |   }
55 | 
56 |   def loadOffset(): Future[Long] =
57 |     Future.successful(offset.get)
58 | 
59 |   def update(data: String): Future[Done] = {
60 |     println(s"DB.update: $data")
61 |     Future.successful(Done)
62 |   }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/producer/CommitConsumerToFlowProducerMain.scala:
--------------------------------------------------------------------------------
 1 | package com.example.producer
 2 | 
 3 | import akka.actor.ActorSystem
 4 | import akka.kafka.scaladsl.{Consumer, Producer}
 5 | import akka.kafka.{ConsumerSettings, ProducerMessage, ProducerSettings, Subscriptions}
 6 | import akka.stream.ActorMaterializer
 7 | import akka.stream.scaladsl.Sink
 8 | import org.apache.kafka.clients.consumer.ConsumerConfig
 9 | import org.apache.kafka.clients.producer.ProducerRecord
10 | import org.apache.kafka.common.serialization.{ByteArrayDeserializer, ByteArraySerializer, StringDeserializer, StringSerializer}
11 | 
12 | /**
13 |   * Created by marksu on 9/7/16.
14 |   */
15 | object CommitConsumerToFlowProducerMain extends App {
16 |   implicit val system = ActorSystem("CommitConsumerToFlowProducerMain")
17 |   implicit val materializer = ActorMaterializer()
18 | 
19 |   val consumerSettings =
20 |     ConsumerSettings(system, new ByteArrayDeserializer, new StringDeserializer)
21 |       .withBootstrapServers("localhost:9092")
22 |       .withGroupId("CommitConsumerToFlowProducer")
23 |       .withProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest")
24 | 
25 |   val producerSettings = ProducerSettings(system, new ByteArraySerializer, new StringSerializer)
26 |     .withBootstrapServers("localhost:9092")
27 | 
28 |   val done =
29 |     Consumer.committableSource(consumerSettings, Subscriptions.topics("topic1"))
30 |       .map { msg =>
31 |         println(s"topic1 -> topic2: $msg")
32 |         ProducerMessage.Message(new ProducerRecord[Array[Byte], String](
33 |           "topic2",
34 |           msg.record.value
35 |         ), msg.committableOffset)
36 |       }
37 |       .via(Producer.flow(producerSettings))
38 |       .mapAsync(producerSettings.parallelism) { result =>
39 |         result.message.passThrough.commitScaladsl()
40 |       }
41 |       .runWith(Sink.ignore)
42 | }
43 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/producer/ConsumerToCommitableSinkProducerMain.scala:
--------------------------------------------------------------------------------
 1 | package com.example.producer
 2 | 
 3 | import akka.actor.ActorSystem
 4 | import akka.kafka.ConsumerMessage.CommittableOffsetBatch
 5 | import akka.kafka.scaladsl.{Consumer, Producer}
 6 | import akka.kafka.{ConsumerSettings, ProducerMessage, ProducerSettings, Subscriptions}
 7 | import akka.stream.ActorMaterializer
 8 | import akka.stream.scaladsl.Sink
 9 | import org.apache.kafka.clients.consumer.ConsumerConfig
10 | import org.apache.kafka.clients.producer.ProducerRecord
11 | import org.apache.kafka.common.serialization.{ByteArrayDeserializer, ByteArraySerializer, StringDeserializer, StringSerializer}
12 | 
13 | /**
14 |   * Created by marksu on 8/31/16.
15 |   */
16 | object ConsumerToCommitableSinkProducerMain extends App {
17 | 
18 |   implicit val system = ActorSystem("Consumer2ProducerMain")
19 |   implicit val materializer = ActorMaterializer()
20 | 
21 |   //TODO: move to configuration application.conf
22 |   val consumerSettings =
23 |     ConsumerSettings(system, new ByteArrayDeserializer, new StringDeserializer)
24 |       .withBootstrapServers("localhost:9092")
25 |       .withGroupId("Consumer2Producer")
26 |       .withProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest")
27 | 
28 |   //TODO: move to configuration application.conf
29 |   val producerSettings =
30 |     ProducerSettings(system, new ByteArraySerializer, new StringSerializer)
31 |       .withBootstrapServers("localhost:9092")
32 | 
33 |   Consumer.committableSource(consumerSettings, Subscriptions.topics("topic1"))
34 |     .map { msg =>
35 |       println(s"topic1 -> topic2: $msg")
36 |       ProducerMessage.Message(new ProducerRecord[Array[Byte], String](
37 |         "topic2",
38 |         msg.record.value
39 |       ), msg.committableOffset)
40 |     }
41 |     .runWith(Producer.commitableSink(producerSettings))
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/producer/FlowProducerMain.scala:
--------------------------------------------------------------------------------
 1 | package com.example.producer
 2 | 
 3 | import akka.actor.ActorSystem
 4 | import akka.kafka.scaladsl.Producer
 5 | import akka.kafka.{ProducerMessage, ProducerSettings}
 6 | import akka.stream.ActorMaterializer
 7 | import akka.stream.scaladsl.{Sink, Source}
 8 | import org.apache.kafka.clients.producer.ProducerRecord
 9 | import org.apache.kafka.common.serialization.{ByteArraySerializer, StringSerializer}
10 | 
11 | /**
12 |   * Created by marksu on 9/6/16.
13 |   */
14 | object FlowProducerMain extends App {
15 |   implicit val system = ActorSystem("FlowProducerMain")
16 |   implicit val materializer = ActorMaterializer()
17 | 
18 |   val producerSettings = ProducerSettings(system, new ByteArraySerializer, new StringSerializer)
19 |     .withBootstrapServers("localhost:9092")
20 | 
21 |   val done = Source(1 to 10)
22 |     .map { n =>
23 |       // val partition = math.abs(n) % 2
24 |       val partition = 0
25 |       ProducerMessage.Message(new ProducerRecord[Array[Byte], String](
26 |         "topic1", partition, null, n.toString
27 |       ), n)
28 |     }
29 |     .via(Producer.flow(producerSettings))
30 |     .map { result =>
31 |       val record = result.message.record
32 |       println(s"${record.topic}/${record.partition} ${result.offset}: ${record.value}" +
33 |         s"(${result.message.passThrough})")
34 |       result
35 |     }
36 |     .runWith(Sink.ignore)
37 | }
38 | 


--------------------------------------------------------------------------------
/src/main/scala/com/example/producer/PlainSinkProducerMain.scala:
--------------------------------------------------------------------------------
 1 | package com.example.producer
 2 | 
 3 | import akka.actor.ActorSystem
 4 | import akka.kafka.ProducerSettings
 5 | import akka.kafka.scaladsl.Producer
 6 | import akka.stream.ActorMaterializer
 7 | import akka.stream.scaladsl.Source
 8 | import org.apache.kafka.clients.producer.ProducerRecord
 9 | import org.apache.kafka.common.serialization.{ByteArraySerializer, StringSerializer}
10 | 
11 | /**
12 |   * Created by marksu on 8/31/16.
13 |   */
14 | object PlainSinkProducerMain extends App {
15 | 
16 |   implicit val system = ActorSystem("PlainSinkProducerMain")
17 |   implicit val materializer = ActorMaterializer()
18 | 
19 |   val producerSettings = ProducerSettings(system, new ByteArraySerializer, new StringSerializer)
20 |     .withBootstrapServers("localhost:9092")
21 | 
22 |   val done = Source(1 to 10)
23 |     .map(_.toString)
24 |     .map { elem =>
25 |       println(s"PlainSinkProducer produce: ${elem}")
26 |       new ProducerRecord[Array[Byte], String]("topic1", elem)
27 |     }
28 |     .runWith(Producer.plainSink(producerSettings))
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/src/test/scala/com/example/PingPongActorSpec.scala:
--------------------------------------------------------------------------------
 1 | package com.example
 2 | 
 3 | import akka.actor.ActorSystem
 4 | import akka.actor.Actor
 5 | import akka.actor.Props
 6 | import akka.testkit.{ TestActors, TestKit, ImplicitSender }
 7 | import org.scalatest.WordSpecLike
 8 | import org.scalatest.Matchers
 9 | import org.scalatest.BeforeAndAfterAll
10 |  
11 | class PingPongActorSpec(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
12 |   with WordSpecLike with Matchers with BeforeAndAfterAll {
13 |  
14 |   def this() = this(ActorSystem("MySpec"))
15 |  
16 |   override def afterAll {
17 |     TestKit.shutdownActorSystem(system)
18 |   }
19 |  
20 |   "A Ping actor" must {
21 |     "send back a ping on a pong" in {
22 |       val pingActor = system.actorOf(PingActor.props)
23 |       pingActor ! PongActor.PongMessage("pong")
24 |       expectMsg(PingActor.PingMessage("ping"))
25 |     }
26 |   }
27 | 
28 |   "A Pong actor" must {
29 |     "send back a pong on a ping" in {
30 |       val pongActor = system.actorOf(PongActor.props)
31 |       pongActor ! PingActor.PingMessage("ping")
32 |       expectMsg(PongActor.PongMessage("pong"))
33 |     }
34 |   }
35 | 
36 | }
37 | 


--------------------------------------------------------------------------------
/tutorial/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <title>Untitled</title>
  7 |   <style type="text/css">
  8 |     body {
  9 |   font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
 10 |   color: #222;
 11 |   font-size: 100%;
 12 | }
 13 | 
 14 | .slide {
 15 |   position: absolute;
 16 |   top: 0; bottom: 0;
 17 |   left: 0; right: 0;
 18 |   background-color: #f7f7f7;
 19 | }
 20 | 
 21 | .slide-content {
 22 |   width: 800px;
 23 |   height: 600px;
 24 |   overflow: hidden;
 25 |   margin: 80px auto 0 auto;
 26 |   padding: 30px;
 27 | 
 28 |   font-weight: 200;
 29 |   font-size: 200%;
 30 |   line-height: 1.375;
 31 | }
 32 | 
 33 | .controls {
 34 |   position: absolute;
 35 |   bottom: 20px;
 36 |   left: 20px;
 37 | }
 38 | 
 39 | .arrow {
 40 |   width: 0; height: 0;
 41 |   border: 30px solid #333;
 42 |   float: left;
 43 |   margin-right: 30px;
 44 | 
 45 |   -webkit-touch-callout: none;
 46 |   -webkit-user-select: none;
 47 |   -khtml-user-select: none;
 48 |   -moz-user-select: none;
 49 |   -ms-user-select: none;
 50 |   user-select: none;
 51 | }
 52 | 
 53 | .prev {
 54 |   border-top-color: transparent;
 55 |   border-bottom-color: transparent;
 56 |   border-left-color: transparent;
 57 | 
 58 |   border-left-width: 0;
 59 |   border-right-width: 50px;
 60 | }
 61 | 
 62 | .next {
 63 |   border-top-color: transparent;
 64 |   border-bottom-color: transparent;
 65 |   border-right-color: transparent;
 66 | 
 67 |   border-left-width: 50px;
 68 |   border-right-width: 0;
 69 | }
 70 | 
 71 | .prev:hover {
 72 |   border-right-color: #888;
 73 |   cursor: pointer;
 74 | }
 75 | 
 76 | .next:hover {
 77 |   border-left-color: #888;
 78 |   cursor: pointer;
 79 | }
 80 | 
 81 | h1 {
 82 |   font-size: 300%;
 83 |   line-height: 1.2;
 84 |   text-align: center;
 85 |   margin: 170px 0 0;
 86 | }
 87 | 
 88 | h2 {
 89 |   font-size: 100%;
 90 |   line-height: 1.2;
 91 |   margin: 5px 0;
 92 |   text-align: center;
 93 |   font-weight: 200;
 94 | }
 95 | 
 96 | h3 {
 97 |   font-size: 140%;
 98 |   line-height: 1.2;
 99 |   border-bottom: 1px solid #aaa;
100 |   margin: 0;
101 |   padding-bottom: 15px;
102 | }
103 | 
104 | ul {
105 |   padding: 20px 0 0 60px;
106 |   font-weight: 200;
107 |   line-height: 1.375;
108 | }
109 | 
110 | .author h1 {
111 |   font-size: 170%;
112 |   font-weight: 200;
113 |   text-align: center;
114 |   margin-bottom: 30px;
115 | }
116 | 
117 | .author h3 {
118 |   font-weight: 100;
119 |   text-align: center;
120 |   font-size: 95%;
121 |   border: none;
122 | }
123 | 
124 | a {
125 |   text-decoration: none;
126 |   color: #44a4dd;
127 | }
128 | 
129 | a:hover {
130 |   color: #66b5ff;
131 | }
132 | 
133 | pre {
134 |   font-size: 60%;
135 |   line-height: 1.3;
136 | }
137 | 
138 | .progress {
139 |   position: fixed;
140 |   top: 0; left: 0; right: 0;
141 |   height: 3px;
142 | }
143 | 
144 | .progress-bar {
145 |   width: 0%;
146 |   height: 3px;
147 |   background-color: #b4b4b4;
148 | 
149 |   -webkit-transition: width 0.05s ease-out;
150 |   -moz-transition: width 0.05s ease-out;
151 |   -o-transition: width 0.05s ease-out;
152 |   transition: width 0.05s ease-out;
153 | }
154 | 
155 | .hidden {
156 |   display: none;
157 | }
158 | 
159 | @media (max-width: 850px) {
160 | 
161 |   body {
162 |     font-size: 70%;
163 |   }
164 | 
165 |   .slide-content {
166 |     width: auto;
167 |   }
168 | 
169 |   img {
170 |     width: 100%;
171 |   }
172 | 
173 |   h1 {
174 |     margin-top: 120px;
175 |   }
176 | 
177 |   .prev, .prev:hover {
178 |     border-right-color: rgba(135, 135, 135, 0.5);
179 |   }
180 | 
181 |   .next, .next:hover {
182 |     border-left-color: rgba(135, 135, 135, 0.5);
183 |   }
184 | }
185 | 
186 | @media (max-width: 480px) {
187 |   body {
188 |     font-size: 50%;
189 |     overflow: hidden;
190 |   }
191 | 
192 |   .slide-content {
193 |     padding: 10px;
194 |     margin-top: 10px;
195 |     height: 340px;
196 |   }
197 | 
198 |   h1 {
199 |     margin-top: 50px;
200 |   }
201 | 
202 |   ul {
203 |     padding-left: 25px;
204 |   }
205 | }
206 | 
207 | @media print {
208 |   * {
209 |     -webkit-print-color-adjust: exact;
210 |   }
211 | 
212 |   @page {
213 |     size: letter;
214 |   }
215 | 
216 |   .hidden {
217 |     display: inline;
218 |   }
219 | 
220 |   html {
221 |     width: 100%;
222 |     height: 100%;
223 |     overflow: visible;
224 |   }
225 | 
226 |   body {
227 |     margin: 0 auto !important;
228 |     border: 0;
229 |     padding: 0;
230 |     float: none !important;
231 |     overflow: visible;
232 |     background: none !important;
233 |     font-size: 52%;
234 |   }
235 | 
236 |   .progress, .controls {
237 |     display: none;
238 |   }
239 | 
240 |   .slide {
241 |     position: static;
242 |   }
243 | 
244 |   .slide-content {
245 |     border: 1px solid #222;
246 |     margin-top: 0;
247 |     margin-bottom: 40px;
248 |     height: 3.5in;
249 |     overflow: visible;
250 |   }
251 | 
252 |   .slide:nth-child(even) {
253 |     /* 2 slides per page */
254 |     page-break-before: always;
255 |   }
256 | }
257 | 
258 | /*
259 | 
260 | github.com style (c) Vasily Polovnyov <vast@whiteants.net>
261 | 
262 | */
263 | 
264 | .hljs {
265 |   display: block;
266 |   overflow-x: auto;
267 |   padding: 0.5em;
268 |   color: #333;
269 |   background: #f8f8f8;
270 | }
271 | 
272 | .hljs-comment,
273 | .hljs-quote {
274 |   color: #998;
275 |   font-style: italic;
276 | }
277 | 
278 | .hljs-keyword,
279 | .hljs-selector-tag,
280 | .hljs-subst {
281 |   color: #333;
282 |   font-weight: bold;
283 | }
284 | 
285 | .hljs-number,
286 | .hljs-literal,
287 | .hljs-variable,
288 | .hljs-template-variable,
289 | .hljs-tag .hljs-attr {
290 |   color: #008080;
291 | }
292 | 
293 | .hljs-string,
294 | .hljs-doctag {
295 |   color: #d14;
296 | }
297 | 
298 | .hljs-title,
299 | .hljs-section,
300 | .hljs-selector-id {
301 |   color: #900;
302 |   font-weight: bold;
303 | }
304 | 
305 | .hljs-subst {
306 |   font-weight: normal;
307 | }
308 | 
309 | .hljs-type,
310 | .hljs-class .hljs-title {
311 |   color: #458;
312 |   font-weight: bold;
313 | }
314 | 
315 | .hljs-tag,
316 | .hljs-name,
317 | .hljs-attribute {
318 |   color: #000080;
319 |   font-weight: normal;
320 | }
321 | 
322 | .hljs-regexp,
323 | .hljs-link {
324 |   color: #009926;
325 | }
326 | 
327 | .hljs-symbol,
328 | .hljs-bullet {
329 |   color: #990073;
330 | }
331 | 
332 | .hljs-built_in,
333 | .hljs-builtin-name {
334 |   color: #0086b3;
335 | }
336 | 
337 | .hljs-meta {
338 |   color: #999;
339 |   font-weight: bold;
340 | }
341 | 
342 | .hljs-deletion {
343 |   background: #fdd;
344 | }
345 | 
346 | .hljs-addition {
347 |   background: #dfd;
348 | }
349 | 
350 | .hljs-emphasis {
351 |   font-style: italic;
352 | }
353 | 
354 | .hljs-strong {
355 |   font-weight: bold;
356 | }
357 | 
358 | 
359 |   </style>
360 | </head>
361 | <body>
362 |     <div class="progress">
363 |     <div class="progress-bar"></div>
364 |   </div>
365 | 
366 |   <div class="slide" id="slide-1">
367 |     <section class="slide-content"><h1 id="reactive-kafka-scala-example">reactive-kafka scala example</h1>
368 | </section>
369 |   </div>
370 |   <div class="slide hidden" id="slide-2">
371 |     <section class="slide-content"><h3 id="install-kafka-on-osx">Install Kafka on OSX</h3>
372 | <pre><code>brew install kafka</code></pre>
373 | <h4 id="start-kafka">Start Kafka</h4>
374 | <pre><code>zkserver start
375 | kafka-server-start /usr/local/etc/kafka/server.properties</code></pre>
376 | <h4 id="start-a-consumer-on-console-for-topic1-topic2">Start a consumer on console for topic1/topic2</h4>
377 | <pre><code>kafka-console-consumer --zookeeper localhost:2181 --topic topic1  --from-beginning
378 | kafka-console-consumer --zookeeper localhost:2181 --topic topic2  --from-beginning</code></pre>
379 | <h4 id="start-a-producer-on-console-for-topic1">Start a producer on console for topic1</h4>
380 | <pre><code>kafka-console-producer --broker-list localhost:9092 --topic topic1</code></pre>
381 | </section>
382 |   </div>
383 |   <div class="slide hidden" id="slide-3">
384 |     <section class="slide-content"><h3 id="start-reactive-kafka-examples">Start reactive-kafka examples</h3>
385 | <pre><code>git clone https://github.com/makersu/reactive-kafka-scala-example.git
386 | cd reactive-kafka-scala-example
387 | sbt run</code></pre>
388 | <pre><code>Multiple main classes detected, select one to run:
389 | 
390 |  [1] com.example.consumer.BatchCommittableSourceConsumerMain
391 |  [2] com.example.consumer.CommittableSourceConsumerMain
392 |  [3] com.example.consumer.PlainSourceConsumerMain
393 |  [4] com.example.producer.CommitConsumerToFlowProducerMain
394 |  [5] com.example.producer.ConsumerToCommitableSinkProducerMain
395 |  [6] com.example.producer.FlowProducerMain
396 |  [7] com.example.producer.PlainSinkProducerMain
397 | 
398 | Enter number:</code></pre>
399 | </section>
400 |   </div>
401 | 
402 |   <div class="controls">
403 |     <div class="arrow prev"></div>
404 |     <div class="arrow next"></div>
405 |   </div>
406 | 
407 | 
408 |   <script type="text/javascript">
409 |     /**
410 |  * Returns the current page number of the presentation.
411 |  */
412 | function currentPosition() {
413 |   return parseInt(document.querySelector('.slide:not(.hidden)').id.slice(6));
414 | }
415 | 
416 | 
417 | /**
418 |  * Navigates forward n pages
419 |  * If n is negative, we will navigate in reverse
420 |  */
421 | function navigate(n) {
422 |   var position = currentPosition();
423 |   var numSlides = document.getElementsByClassName('slide').length;
424 | 
425 |   /* Positions are 1-indexed, so we need to add and subtract 1 */
426 |   var nextPosition = (position - 1 + n) % numSlides + 1;
427 | 
428 |   /* Normalize nextPosition in-case of a negative modulo result */
429 |   nextPosition = (nextPosition - 1 + numSlides) % numSlides + 1;
430 | 
431 |   document.getElementById('slide-' + position).classList.add('hidden');
432 |   document.getElementById('slide-' + nextPosition).classList.remove('hidden');
433 | 
434 |   updateProgress();
435 |   updateURL();
436 |   updateTabIndex();
437 | }
438 | 
439 | 
440 | /**
441 |  * Updates the current URL to include a hashtag of the current page number.
442 |  */
443 | function updateURL() {
444 |   try {
445 |     window.history.replaceState({} , null, '#' + currentPosition());
446 |   } catch (e) {
447 |     window.location.hash = currentPosition();
448 |   }
449 | }
450 | 
451 | 
452 | /**
453 |  * Sets the progress indicator.
454 |  */
455 | function updateProgress() {
456 |   var progressBar = document.querySelector('.progress-bar');
457 | 
458 |   if (progressBar !== null) {
459 |     var numSlides = document.getElementsByClassName('slide').length;
460 |     var position = currentPosition() - 1;
461 |     var percent = (numSlides === 1) ? 100 : 100 * position / (numSlides - 1);
462 |     progressBar.style.width = percent.toString() + '%';
463 |   }
464 | }
465 | 
466 | 
467 | /**
468 |  * Removes tabindex property from all links on the current slide, sets
469 |  * tabindex = -1 for all links on other slides. Prevents slides from appearing
470 |  * out of control.
471 |  */
472 | function updateTabIndex() {
473 |   var allLinks = document.querySelectorAll('.slide a');
474 |   var position = currentPosition();
475 |   var currentPageLinks = document.getElementById('slide-' + position).querySelectorAll('a');
476 |   var i;
477 | 
478 |   for (i = 0; i < allLinks.length; i++) {
479 |     allLinks[i].setAttribute('tabindex', -1);
480 |   }
481 | 
482 |   for (i = 0; i < currentPageLinks.length; i++) {
483 |     currentPageLinks[i].removeAttribute('tabindex');
484 |   }
485 | }
486 | 
487 | /**
488 |  * Determines whether or not we are currently in full screen mode
489 |  */
490 | function isFullScreen() {
491 |   return document.fullscreenElement ||
492 |          document.mozFullScreenElement ||
493 |          document.webkitFullscreenElement ||
494 |          document.msFullscreenElement;
495 | }
496 | 
497 | /**
498 |  * Toggle fullScreen mode on document element.
499 |  * Works on chrome (>= 15), firefox (>= 9), ie (>= 11), opera(>= 12.1), safari (>= 5).
500 |  */
501 | function toggleFullScreen() {
502 |   /* Convenient renames */
503 |   var docElem = document.documentElement;
504 |   var doc = document;
505 | 
506 |   docElem.requestFullscreen =
507 |       docElem.requestFullscreen ||
508 |       docElem.msRequestFullscreen ||
509 |       docElem.mozRequestFullScreen ||
510 |       docElem.webkitRequestFullscreen.bind(docElem, Element.ALLOW_KEYBOARD_INPUT);
511 | 
512 |   doc.exitFullscreen =
513 |       doc.exitFullscreen ||
514 |       doc.msExitFullscreen ||
515 |       doc.mozCancelFullScreen ||
516 |       doc.webkitExitFullscreen;
517 | 
518 |   isFullScreen() ? doc.exitFullscreen() : docElem.requestFullscreen();
519 | }
520 | 
521 | document.addEventListener('DOMContentLoaded', function () {
522 |   // Update the tabindex to prevent weird slide transitioning
523 |   updateTabIndex();
524 | 
525 |   // If the location hash specifies a page number, go to it.
526 |   var page = window.location.hash.slice(1);
527 |   if (page) {
528 |     navigate(parseInt(page) - 1);
529 |   }
530 | 
531 |   document.onkeydown = function (e) {
532 |     var kc = e.keyCode;
533 | 
534 |     // left, down, H, J, backspace, PgUp - BACK
535 |     // up, right, K, L, space, PgDn - FORWARD
536 |     // enter - FULLSCREEN
537 |     if (kc === 37 || kc === 40 || kc === 8 || kc === 72 || kc === 74 || kc === 33) {
538 |       navigate(-1);
539 |     } else if (kc === 38 || kc === 39 || kc === 32 || kc === 75 || kc === 76 || kc === 34) {
540 |       navigate(1);
541 |     } else if (kc === 13) {
542 |       toggleFullScreen();
543 |     }
544 |   };
545 | 
546 |   if (document.querySelector('.next') && document.querySelector('.prev')) {
547 |     document.querySelector('.next').onclick = function (e) {
548 |       e.preventDefault();
549 |       navigate(1);
550 |     };
551 | 
552 |     document.querySelector('.prev').onclick = function (e) {
553 |       e.preventDefault();
554 |       navigate(-1);
555 |     };
556 |   }
557 | });
558 | 
559 | 
560 |   </script>
561 | </body>
562 | </html>
563 | 


--------------------------------------------------------------------------------
/tutorial/index.md:
--------------------------------------------------------------------------------
 1 | reactive-kafka-scala-example.md
 2 | --
 3 | # reactive-kafka scala example
 4 | --
 5 | ### Install Kafka on OSX
 6 | ```
 7 | brew install kafka
 8 | ```
 9 | 
10 | #### Start Kafka
11 | ```
12 | zkserver start
13 | kafka-server-start /usr/local/etc/kafka/server.properties
14 | ```
15 | 
16 | #### Start a consumer on console for topic1/topic2
17 | ```
18 | kafka-console-consumer --zookeeper localhost:2181 --topic topic1  --from-beginning
19 | kafka-console-consumer --zookeeper localhost:2181 --topic topic2  --from-beginning
20 | ```
21 | 
22 | #### Start a producer on console for topic1
23 | ```
24 | kafka-console-producer --broker-list localhost:9092 --topic topic1
25 | ```
26 | --
27 | ### Start reactive-kafka examples
28 | ```
29 | git clone https://github.com/makersu/reactive-kafka-scala-example.git
30 | cd reactive-kafka-scala-example
31 | sbt run
32 | ```
33 | ```
34 | Multiple main classes detected, select one to run:
35 | 
36 |  [1] com.example.consumer.BatchCommittableSourceConsumerMain
37 |  [2] com.example.consumer.CommittableSourceConsumerMain
38 |  [3] com.example.consumer.PlainSourceConsumerMain
39 |  [4] com.example.producer.CommitConsumerToFlowProducerMain
40 |  [5] com.example.producer.ConsumerToCommitableSinkProducerMain
41 |  [6] com.example.producer.FlowProducerMain
42 |  [7] com.example.producer.PlainSinkProducerMain
43 | 
44 | Enter number:
45 | ```
46 | 
47 | 
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------