Sadek Drobi sadache

If your csv doesn't contain escaped newlines then it is pretty easy to do a progressive parsing without putting the whole file into memory. The iteratee library comes with a method search inside play.api.libs.iteratee.Parsing :

def search (needle: Array[Byte]): Enumeratee[Array[Byte], MatchInfo[Array[Byte]]]

which will partition your stream into Matched[Array[Byte]] and Unmatched[Array[Byte]]

Then you can combine a first iteratee that takes a header and another that will fold into the umatched results. This should look like the following code:

// break at each match and concat unmatches and drop the last received element (the match)

Bits'bout Play2 Architecture

Play2 Simple HTTP API

Essential blueprint of Play2 architecture is pretty simple and it should be easy to explain in a fairly short blog post. The framework can be understood progressively at different levels; each time having better exposure to some aspects of its design.

The core of Play2 is really small, surrounded by a fair amount of useful APIs, services and structure to make Web Programming tasks easier.

Basically, Play2 is an API that abstractly have the folllowing type

Is socket.push(bytes) all you need to program Realtime Web apps?

One of the goals of Play2 architecture is to provide a programming model for what is called Realtime Web Applications.

Realtime Web Applications

Realtime Web Applications are applications that make use of Websockets, Server Sent Events, Comet or other protocols offering/simulating an open socket between the browser and the server for continuous communication. Basically, these applications let users work with information as it is published - without having to periodically ping the service.

There are quite a few web frameworks that target the development of this type of application: but usually the solution is to simply provide an API that allows developers to push/receive messages from/to an open channel, something like:

This post aims to document a practical design implementation we came up with when designing some APIs in Scala. Of course the concept is not Scala specific and applies to other functional languages.

If you don't want to go into the full introduction, this post talks about how Applicatives are too restrictive and breaking them into two independent components can be interesting for Contravariant and Invariant Functors. Jump to implementation attached.

We are taking JSON serialization/deserialization as a motivating example.

JsValue is the name of the type that represents the JSON AST. What we need is to be able to read a JsValue and produce an A:

trait Reads[A]{

Asynchronicity is the price to pay, you better know what you're paying for...

Let's share some vocabulary first:

Thread: The primitive responsible of executing code on the processor, you can give an existing (or a new) Thread some code, and it will execute it. Normally you can have a few hundreds on a JVM, arguments that you can tweak your way out to thousands. Worth noting that multitasking is achieved when using multiple Threads. Multiple Threads can exist for a single processor in which case multitasking happens when this processor switches between threads, called context switching, which will give the impression of things happenning in parallel. An example of a direct, and probably naive, use of a new Thread in Java:

public class MyRunnable implements Runnable {
  public void run(){
 System.out.println("MyRunnable running");

	package controllers

	import play.api._
	import play.api.mvc._
	import play.api.libs.ws._
	import play.api.libs.iteratee._
	import play.api.libs.concurrent._

	object Application extends Controller {

	package controllers

	import play.api._
	import play.api.mvc._


	object Application extends Controller {

	def index = Action {

	Enumeratee.map[Array[Byte]]{ e =>
	val length = e.size
	val CRLF = "\r\n".getBytes("UTF-8")
	(length.toHexString.getBytes ++ CRLF ++ e ++ CRLF):Array[Byte]
	} ><>
	Enumeratee.trailing(Seq((0.toHexString.getBytes) ++ (CRLF ++ CRLF)))

	"copy file" in {

	val fileGenerator = Enumerator.repeat(new java.util.Date.getTime.toString + "\n").through(Enumeratee.take(1000))
	//val fileGenerator = Enumerator.repeat(new java.util.Date.getTime.toString + "\n") &>> Enumeratee.take(1000)

	val f = FileChannel("/tmp/testwrite.txt").delete.writing.create
	val f2 = FileChannel("/tmp/testwrite2.txt").delete.writing.create

	fileGenerator // generates data
	.through(RichEnumeratee.binarize()) // binarizes data to write into File

	ackage controllers

	import play.api._
	import play.api.mvc._
	import play.api.libs.iteratee._
	import play.api.libs.EventSource
	import scala.concurrent.ExecutionContext.Implicits.global
	import scala.concurrent.{Future, Promise}

	// Solves memory leaks