Server Side Swift with Swag

let me = Person(name: "Jens Ravens", company: "nerdgeschoss")
@JensRavens
GitHub: JensRavens
jensravens.com
nerdgeschoss.de

A short introduction to
http, tcp and ip.

Browser
http://jensravens.com
DNS Server

Browser
DNS Server
;; ANSWER SECTION:
jensravens.com. 3600 INA 37.120.178.83

Browser
DNS Server
;; ANSWER SECTION:
jensravens.com. 3600 INA 37.120.178.83
37.120.178.83

Browser
DNS Server
37.120.178.83

Browser
DNS Server
37.120.178.83
GET / HTTP/1.1
Host: jensravens.com
User-Agent: curl/7.43.0
Accept: */*

Browser
DNS Server
37.120.178.83
Server
GET / HTTP/1.1
Accept: */*

Browser
DNS Server
37.120.178.83
Server
Load Balancer
GET / HTTP/1.1
Accept: */*

Browser
DNS Server
37.120.178.83
Server
Load Balancer
App App
GET / HTTP/1.1
Accept: */*

Browser
DNS Server Server
Load Balancer
App App

HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 7897
Connection: Keep-Alive
<!DOCTYPE html>
Browser
DNS Server Server
Load Balancer
App App

Hey, that’s just some
plain text over tcp!

Get a Request,
give a Response

public protocol RequestType {
var context: [String:AnyObject] { get set }
var method: HTTPMethod { get }
var path: String { get }
var params: [String:String] { get }
var headers: [String:String] { get }
var format: Format { get }
var body: Streamable? { get }
}

public protocol ResponseType {
var headers: [String: HeaderType] { get }
var code: StatusCode { get }
var content: Streamable { get }
}
}

public protocol ResponseType {
var headers: [String: HeaderType] { get }
var code: StatusCode { get }
var content: Streamable { get }
}
}
public protocol Streamable {
var stream: Void -> NSData? { get }
}

public typealias AppType = RequestType throws
-> ResponseType

public typealias AppType = RequestType throws
-> ResponseType
let myApp: AppType = { request in
return Response(code: 200, headers: [:],
content: "Hello World")
}

public final class Router {
public func route(method: HTTPMethod, path: String,
app: Void -> AppType)
public func get(path: String, app: Void -> AppType)
public func app(request: RequestType) throws
-> ResponseType
}

-> ResponseType
}
}

-> ResponseType
}
}
let router = Router()
router.get("home") { myApp }
let routedApp = router.app

Making things pretty -
Rendering Views

public protocol ViewType {
func render() throws -> Streamable
var contentType: FormatType { get }
}

public protocol ViewType {
func render() throws -> Streamable
var contentType: FormatType { get }
}
public struct JSONView: ViewType {
public var contentType: FormatType { return Format.JSON }
let contents: AnyObject
public init(_ contents: AnyObject) {
self.contents = contents
}
public func render() throws -> Streamable {
return try NSJSONSerialization.dataWithJSONObject(
contents, options: .PrettyPrinted)
}
}

public protocol ControllerType {}
extension ControllerType {
func redirect(path: PathConvertible,
statusCode: StatusCode = 302) -> ResponseType
func render(view view: ViewType,
statusCode: StatusCode = 200) throws -> ResponseType
func render(json json: AnyObject,
func render(html html: String,
}

struct UsersController: ControllerType {
func index(request: RequestType) throws -> ResponseType {
let users: [User] = …
switch request.format {
case .JSON:
return try render(json: users.map { $0.json })
default:
return try render(view: MustacheView(name: "template",
context: users))
}
}
}

struct UsersController: ControllerType {
func index(request: RequestType) throws -> ResponseType {
let users: [User] = …
switch request.format {
case .JSON:
return try render(json: users.map { $0.json })
default:
return try render(view: MustacheView(name: "template",
context: users))
}
}
}
router.get(“/users") { UsersController().index }

Extending the Stack -
Add some Middleware

public typealias MiddlewareType = AppType -> AppType
public func + (lhs: MiddlewareType, rhs: AppType) -> AppType {
return lhs(rhs)
}

return lhs(rhs)
}
let awesomeMiddleware: MiddlewareType = { app in
return { request in
var response = try app(request)
response.content = "Overwritten by middleware"
return response
}
}

return lhs(rhs)
}
let awesomeMiddleware: MiddlewareType = { app in
return { request in
var response = try app(request)
response.content = "Overwritten by middleware"
return response
}
}
router.get(“/users")
{ awesomeMiddleware + UsersController().index }

class CookieStore {
struct Cookie {
public var name: String
public var value: String
public var validUntil: NSDate?
}
var cookies = [String:Cookie]()
subscript(key: String) -> String?
static func middleware(app: AppType) -> AppType
}

class CookieStore {
struct Cookie {
}
}
{ CookieStore().middleware + UsersController().index }

class CookieStore {
struct Cookie {
}
}
{ CookieStore().middleware + UsersController().index }
extension RequestType {
public var cookies: CookieStore!
}

func login(request: RequestType) throws -> ResponseType {
let secret = request.params["secret"] ?? ""
request.cookies["secret"] = secret
return try render(text: "Login successfull")
}
func secretStuff(request: RequestType) throws -> ResponseType {
if request.cookies["secret"] == "superSecret" {
return try render(text: "Here's the secret page")
} else {
return try render(text: "Permission denied!",
status: 403)
}
}

func login(request: RequestType) throws -> ResponseType {
let secret = request.params["secret"] ?? ""
request.cookies["secret"] = secret
return try render(text: "Login successfull")
}
func secretStuff(request: RequestType) throws -> ResponseType {
if request.cookies["secret"] == "superSecret" {
return try render(text: "Here's the secret page")
} else {
return try render(text: "Permission denied!",
status: 403)
}
}
router.post(“/login”)
{ CookieStore().middleware + login }
router.get(“/my-secret-page“)
{ CookieStore().middleware + secretStuff }

Middleware
Cookies
Sessions
Current User
Format Detection
Custom Error Pages
HTTP Body Parser
Static File Server
Analytics

Nest Server Interface
https://github.com/nestproject/Nest
import Curassow
import Inquiline
serve { request in
return Response(.Ok, contentType: "text/plain",
body: "Hello World")
}

Epoch
https://github.com/Zewo/Epoch
struct ServerResponder: ResponderType {
func respond(request: Request) -> Response {
// do something based on the Request
return Response(status: .OK)
}
}
let responder = ServerResponder()
let server = Server(port: 8080, responder: responder)
server.start()

Swag
https://github.com/swagproject/swag
import Foundation
import Curassow
import SwagNest
final class NextApp: App {
override init() {
super.init()
register(FileServer(root: publicDir).serve)
register(BodyParser.middleware)
register(CookieStore.middleware)
router.get(“/users") { UsersController.middleware +
UsersController().index }
router.get("/users/:id") { UsersController().show }
}
}
serve(NextApp().nest)

Thank you.
@JensRavens
github.com/swagproject/swag

Server Side Swift with Swag

More Related Content

What's hot

Similar to Server Side Swift with Swag

More from Jens Ravens

Recently uploaded

Server Side Swift with Swag