Daniel Dietrich danieldietrich

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:

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)

	// Missing support libraries
	object MissingLibraries {
	case class State[S, +A](run: S => (A, S)) {
	def map[B](f: A => B): State[S, B] =
	State(s => {
	val (a, t) = run(s)
	(f(a), t)
	})

	def flatMap[B](f: A => State[S, B]): State[S, B] =

	"copy file" in {
	var i = 0
	val fileGenerator = Enumerator.fromCallback( () =>
	if(i<1000){ i+=1; Future.successful(Some((new java.util.Date).getTime.toString + "\n")) } else Future(None)
	)

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

	fileGenerator // generates data

	object Sql {
	import scala.reflect.makro._
	import language.experimental.macros

	case class Query[R](/sql: String/)

	def execute[R](q: Query[R]): Seq[R] = sys.error("implement me")

	def sqlImpl(c: Context)(s: c.Expr[String]): c.Expr[Any] = {
	import c.universe._

	case class ReaderWriterStateT[R, W, S, F[_], A](
	run: (R, S) => F[(W, A, S)]
	) {
	def map[B](f: A => B)(implicit F: Functor[F])
	: ReaderWriterStateT[R, W, S, F, B] =
	ReaderWriterStateT {
	case (r, s) => F.map(run(r, s)) {
	case (w, a, s) => (w, f(a), s)
	}
	}

	# Upstart script for a play application that binds to an unprivileged user.
	# put this into a file like /etc/init/play.conf
	#
	# This could be the foundation for pushing play apps to the server using something like git-deploy
	# By calling service play stop in the restart command and play-start in the restart command.
	#
	# Usage:
	# start play
	# stop play
	# restart play

	/*
	* This work is free. You can redistribute it and/or modify it under the
	* terms of the Do What The Fuck You Want To Public License, Version 2,
	* as published by Sam Hocevar. See the COPYING file for more details.
	*/
	/*
	* Easing Functions - inspired from http://gizma.com/easing/
	* only considering the t value for the range [0, 1] => [0, 1]
	*/
	EasingFunctions = {

	object Scala extends App {
	import scala.collection.mutable.ArrayBuffer
	import scala.annotation.tailrec
	val items = List("foo", 23, true)
	val before = System.currentTimeMillis()
	@tailrec def adds(n: Int, absoluteResult: ArrayBuffer[Any] = ArrayBuffer()): ArrayBuffer[Any] = {
	def foo(obj : Any) = obj match {
	case _:String => "String"
	case _:Boolean => "Boolean"
	case _:Integer => "Integer"

	function average (arr)
	{
	return _.reduce(arr, function(memo, num)
	{
	return memo + num;
	}, 0) / arr.length;
	}