An Introduction to Finagle by example

libraryDependencies ++= Seq(
"com.twitter" %% "finagle-http" % "6.38.0",
"org.scalatest" %% "scalatest" % "2.2.4" % "test"
)

import com.twitter.finagle.Serviceimport
import com.twitter.util.Futureimport
import com.twitter.finagle.http

// This is a plus 10 service
class PlusTenService extends Service[http.Request, http.Response] {

  override def apply(request: http.Request): Future[http.Response] = {
  	Future {
  		val input = request.getIntParam("num")
  		val output = input + 10
  		val response = http.Response(request.version, http.Status.Ok)
        response.setContentString(output.toString)
        response
    }
  }
}

import com.twitter.finagle.{http, Service, Http}
import com.twitter.util.Await

object QuickLookServer {
	def main(args: Array[String]): Unit = {
    val service: Service[http.Request, http.Response] = new PlusTenService    	  val server = Http.serve(":9090", service)
    Await.ready(server)
    }
}

import com.twitter.finagle.{Service, Http}
import com.twitter.finagle.http
import com.twitter.util.Await

object QuickLookClient {
	def main(args: Array[String]): Unit = {
    	//define a client
    	val client: Service[http.Request, http.Response] = Http.newService("localhost:9090")
		//define a request
		val request = http.Request(http.Method.Get, "/?num=5")
		//apply request on the client
		val response = client(request)
		// print response
		response.foreach(rep => println(rep.getContentString()))
		Await.result(response)
    }
}

// create a http client
val client = Http.client.newService("example.com:80")

// create a http requestval
req = Request("/foo", ("my-query-string", "bar"))
// apply request on the client

val resp: Future[Response] = client(req)Note: client(req) is equal to client.apply(req)

val name: Name = Name.bound(Address("localhost", 10010), Address("localhost", 10011), Address("localhost", 10012))

//define a client
val client: Service[http.Request, http.Response] = Http.newService(name, "client")

import org.jboss.netty.buffer.{ChannelBuffer, ChannelBuffers}
import org.jboss.netty.channel.{Channel, ChannelHandlerContext}
import org.jboss.netty.handler.codec.oneone.{OneToOneDecoder,OneToOneEncoder}
import scodec.Codec
import scodec.bits.BitVector

trait CodecConversions {
/**
 * Converts an scodec codec into a Netty encoder.
 */
 protected def encoder[A: Codec] = new OneToOneEncoder {
	override def encode(ctx: ChannelHandlerContext, channel: Channel, msg: Object) =
	ChannelBuffers.wrappedBuffer(
      Codec.encodeValid(msg.asInstanceOf[A]).toByteBuffer)
 }

 /**
  * Converts an scodec codec into a Netty decoder.
  */
protected def decoder[A: Codec] = new OneToOneDecoder {
  override def decode(ctx: ChannelHandlerContext, channel: Channel, msg: Object) =
  msg match {
     case cb: ChannelBuffer =>
     	Codec.decodeValidValue[A (BitVector(cb.toByteBuffer)).asInstanceOf[Object]
      case other => other
      }
  }
}

trait Factories {
	this: CodecConversions =>
    	import com.twitter.finagle.{Codec => FinagleCodec, CodecFactory}
        import org.jboss.netty.channel.{ChannelPipelineFactory, Channels}

  		/**
         * Creates a Netty channel pipeline factory given input and output types.   */

    private[this] def pipeline[I: Codec, O: Codec] = new ChannelPipelineFactory {
    def getPipeline = {
    	val pipeline = Channels.pipeline()
        pipeline.addLast("encoder", encoder[I])
        pipeline.addLast("decoder", decoder[O])
        pipeline
    }
  }
  /**
  * Creates a Finagle codec factory given input and output types.   */

  protected def codecFactory[I: Codec, O: Codec] = new CodecFactory[I, O] {

	def server = Function.const {
  		new FinagleCodec[I, O] { def pipelineFactory = pipeline[O, I] }
  	}

    def client = Function.const {
    	new FinagleCodec[I, O] { def pipelineFactory = pipeline[I, O] }
    }
  }
}

import java.net.InetSocketAddress

import com.twitter.conversions.time._
import com.twitter.finagle.Service
import com.twitter.finagle.builder.{ClientBuilder, ServerBuilder}
import com.twitter.util.{Duration, Future}
import scodec.Codec

object IntegerServerAndClient extends Factories with CodecConversions {

  /**
   * Creates a Finagle server from a service that we have scodec codecs
   * for both the input and output types.    */

	def server[I, O](port: Int)(service: Service[I, O])(implicit ic: Codec[I], oc: Codec[O]) =
    ServerBuilder()
  		.name("server")
  		.codec(codecFactory[I, O])
  		.bindTo(new InetSocketAddress(port))
        .build(service)

  /**
   * Creates a Finagle client given input and output types with scodec codecs.
   */

   def client[I, O](host: String, timeout: Duration = 3.second)           (implicit ic: Codec[I], oc: Codec[O]) =
   ClientBuilder()
  	.name("client")
  	.codec(codecFactory[I, O])
  	.hosts(host)
  	.timeout(timeout)
  	.build()
}

import com.twitter.finagle.Service
import com.twitter.util.Future

class IntegerService extends Service[Int, Int] {
	var count = 0
    override def apply(request: Int): Future[Int] = {
    	Future.value(count + request)
    }
}

import com.twitter.finagle.Service
import com.twitter.util.Await
import scodec.codecs.implicits.{ implicitIntCodec => _, _ }

object Server {
	def main(args: Array[String]): Unit = {
    	implicit val intgerCodec = scodec.codecs.uint8

    	val service: Service[Int, Int] = new IntegerService
    	val server = IntegerServerAndClient.server[Int, Int](9191)(service)
        Await.ready(server)
    }
}

import com.twitter.finagle.Service
import com.twitter.util.Await
import scodec.codecs.implicits.{ implicitIntCodec => _, _ }

object Client {

	def main(args: Array[String]): Unit = {

   	 	implicit val intgerCodec = scodec.codecs.uint8

    	//define a client
    	val client: Service[Int, Int] = IntegerServerAndClient.client[Int, Int]("localhost:9191")

    	//define a request
    	val request = 4
    	//apply request on the client
    	val response = client(request)
    	//print response
    	response.foreach(rep => println(s"This is response $rep"))
    	Await.result(response)
    }
}