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

Recomendados

Recomendados

Más contenido relacionado

Similar a Unfiltered Unveiled

Similar a Unfiltered Unveiled (20)

Más de Wilfred Springer

Más de Wilfred Springer (12)

Último

Último (20)

Unfiltered Unveiled