Unfiltered Unveiled

Unfiltered Unveiled
The Un-framework
© Wilfred Springer, 2015 | http://www.ﬂotsam.nl/

Whoami
Code/train Scala/Node.js for a living
* Currently @ Gust
* Formerly @ ProQuest Flow
* Formerly @ ProQuest Udini
* Formerly @ Bol.com
* Formerly @ Xebia
* Formerly @ TomTom
* Formerly @ Sun Microsystems

What are we trying to solve here?
GET / HTTP/1.0 HTTP/1.1 200 OK
Host: nxt.flotsam.nl Date: Mon, 27 April, 2015
Accept: text/html …
Last-Modified: …
ETag: "4ce43…"
Content-Type: text/html
Content-Length: 9636
Server: AmazonS3
Content:
…

And therefore, we shall have an
∞/insane number of web
frameworks

HTTP
Stuff => Stuff

HTTP
Request => Response

Web Application
Request1 => Response1

Wait, that rings a bell
… match {
case Request1 => Response1
}

Pattern matching
def doubleOf(obj: Any) = {
obj match {
case i: Int => i * 2
case s: String => s + s
}
}

Partial Function
{
}

Partial Function
val doubleOf = PartialFunction[Any, Any] = {
}
doubleOf(3) // 6
doubleOf("ha") // haha

Unﬁltered Anatomy
The Intent (Simpliﬁed)
type Intent = PartialFunction[HttpRequest, ResponseFunction]

Unﬁltered Anatomy
The Intent
type Intent[A,B] = PartialFunction[
HttpRequest[A], // A: some request representation
ResponseFunction[B] // B: some response representation
]

Unﬁltered Anatomy
The Intent
{
case _ => ResponseString("yay")
}
---------------------------------
GET / => HTTP/1.1 200 OK
Content-Length: 3
Content:
yay

Unﬁltered Anatomy
Binding
import unfiltered.filter
import unfiltered.netty
// Turn it into a Jetty compatible Filter
val plan = filter.Planify(intent)
// Turn it into something Netty compatible
val plan = netty.cycle.Planify(intent)

Unﬁltered Anatomy
Launching
import unfiltered.jetty
import unfiltered.filter
import unfiltered.netty
// Turn it into a Jetty compatible Filter
val plan = filter.Planify(intent)
jetty.Server.http(8080).plan(plan).run()
// Turn it into something Netty compatible
val plan = netty.cycle.Planify(intent)
netty.Server.http(8080).plan(plan).run()

ResponseFunction
Simpliﬁed, and not really true
trait ResponseFunction[-A]
extends HttpResponse[A] => HttpResponse[A]

ResponseFunction
case … => …
case … => … ~> … ~> …
------------------------------------
Ok Html(…)
NotFound Html5(…)
ResponseString(…) JsonContent
Json(…) TextXmlContent
ResponseWriter(…) Redirect(…)

ResponseFunction
Ok ~> PlainTextContent ~> ResponseString("foo")
-----------------------------------------------------------
Ok resp.setStatus(SC_OK)
PlainTextContent resp.setContentType("text/plain")
ResponseString("foo") resp.setCharacterEncoding("UTF-8")
val writer = resp.getWriter()
writer.print("foo")
writer.close

ResponseFunction
Composition using ~>
Ok ~> PlainTextContent ~> ResponseString("foo")
NotFound ~> HtmlContent ~> Html(<html>
<body>Not found</body>
</html>)
Redirect("/index.html")

Or rather…
Scalate
// index.scaml
!!! 5
%html
%head
%body Not found
// .scala
import unfiltered.scalate.Scalate
Ok ~> HtmlContent ~> Scalate(req, "/index.scaml")

Matching the HttpRequest
case … => …
case … & … & … =>
GET(…) Accept(…)
POST(…) UserAgent(…)
DELETE(…) Host(…)
PUT(…) IfModifiedSince(…)
Path(…) Referer(…)

Matching the HttpRequest
Samples
case _ =>
case GET(Path('/index'))
case GET(Path(p)) if p endsWith ".json"
case Path(Seg("give", "it", "to", "me" :: Nil))
case Path("/") & Params(params)
case Accept("application/json")

It's just extractors, dude
object DotJson {
unapply[A](req: HttpRequest[A]) = req.uri endsWith ".json"
}
case DotJson() => ResponseString("Json!")

Summary so far
— An Intent is just a partial function
— accepting an HttpRequest,
— producing a ResponseFunction
— … which will in turn produce an HttpResponse
— Matching based on HttpRequest extractors
— Use & to compose HttpRequest extractors
— Use ~> to compose ResponseFunctions

Upping our game
What else do we need?

Reusable Composite ResponseFunctions
Don't Repeat Yourself
… => Ok ~> HtmlContent ~> Html(<html><body>text1</body></html>)
// vs
case class Html5(text: String)
extends ComposeResponse(
Ok ~> HtmlContent ~> Html(<html><body>{text}</body></html>)
)
… => Html5("text1")

Cross Cutting Concerns
or, how to use Spring AOP

How NOT to use Spring AOP

Kit
In general, a Kit is something that:
— Takes an Intent (but it doesn't have to)
— Produces an Intent (which it always has to)
Anything that produces an Intent should be considered
a Kit

Authentication
import unfiltered.kit.Auth
def verify(username: String, password: String): Boolean = …
Auth.basic(verify) { | {
case … => … | case … => …
case … => … | case … => …
case … => … | case … => …
} | }

// Can you tell the issue with this code?
import unfiltered.request._
import unfiltered.response._
val Simple = unfiltered.filter.Planify {
case Path("/") & Accepts.Json(_) =>
JsonContent ~> ResponseString("""{ "response": "Ok" }""")
}
unfiltered.jetty.Server(8080).plan(Simple).run()

Directives for error handling
import unfiltered.directives._, Directives._
val Smart = unfiltered.filter.Planify { Directive.Intent {
case Path("/") =>
for {
_ <- Accepts.Json
} yield JsonContent ~> ResponseString("""{ "response": "Ok" }""")
} }
unfiltered.jetty.Server(8080).plan(Smart).run()

Directives for routing
val Sweet = unfiltered.filter.Planify { Directive.Intent.Path {
case "/" =>
for {
_ <- Accepts.Json
} yield JsonContent ~> ResponseString("""{ "response": "Ok" }""")
} }
unfiltered.jetty.Server(8080).plan(Sweet).run()

Parameter Based Routing
Primitive (never do this)
case Params(ps) if ps contains "name" =>
val name = ps.get("name").head

No longer preferred
// Building extractor for name parameter
object Name extends Params.Extract("name", Params.first)
case GET("/") & Name(name) =>

Getting it right with Directives and Interpreters
Directive.Intent {
case Path("/") =>
for {
name <- data.as.String ~> required named "name"
} yield ResponseString(name)
}

Unfiltered Unveiled

Recommended

Recommended

More Related Content

Similar to Unfiltered Unveiled

Similar to Unfiltered Unveiled (20)

More from Wilfred Springer

More from Wilfred Springer (12)

Recently uploaded

Recently uploaded (20)

Unfiltered Unveiled