Requires Leopard beta 1 and Vapor 2

VaporLeopardBridge.swift

import Vapor
import Leopard
import Lynx
import Sockets
import HTTP

public final class LynxServer : ServerProtocol, AsyncRouter {
    public func register(at path: [String], method: Lynx.Method?, isFallbackHandler: Bool, handler: @escaping RequestHandler) {
        router.register(at: path, method: method, isFallbackHandler: isFallbackHandler, handler: handler)
    }
    
    public func handle(_ request: Lynx.Request, for remote: HTTPRemote) {
        router.handle(request, for: remote)
    }
    
    public init(hostname: String, port: Port, _ securityLayer: SecurityLayer) throws {
        self.server = try HTTPServer(hostname: hostname, port: port, handler: self.handle)
    }
    
    var server: HTTPServer!
    var responder: Responder? = nil
    var router = TrieRouter()
    
    public func start(_ responder: Responder, errors: @escaping ServerErrorHandler) throws {
        self.router.fallbackHandler = { request, remote in
            do {
                let response = try responder.respond(to: request.vaporRequest)
                let lynxResponse = try response.makeResponse() as Lynx.Response
                
                try remote.send(lynxResponse)
            } catch {
                remote.error(error)
            }
        }
        
        try self.server.start()
    }
}

public final class LynxFactory : ServerFactoryProtocol {
    public var lynx: LynxServer
    
    public func makeServer(hostname: String, port: Port, _ securityLayer: SecurityLayer) throws -> ServerProtocol {
        return lynx
    }
    
    public init(hostname: String = "0.0.0.0", port: UInt16) throws {
        self.lynx = try LynxServer(hostname: hostname, port: port, SecurityLayer.none)
    }
}

extension Lynx.Request {
    var vaporRequest: Vapor.Request {
        let method = HTTP.Method(self.method.string)
        var path = self.path.rawValue
        if let index = path.index(of: "?") {
            path.removeSubrange(index..<path.endIndex)
        }
        
        let hostname = String(self.headers["Host"]) ?? ""
        
        var headers = [HTTP.HeaderKey : String]()
        
        for (key, value) in self.headers {
            headers[HTTP.HeaderKey(key.rawValue)] = value.rawValue
        }
        
        var body: HTTP.Body
        
        do {
            if let currentBody = try self.body?.makeBody() {
                body = .data(Array(currentBody.buffer))
            } else {
                body = .data([])
            }
        } catch {
            body = .data([])
        }
        
        return Vapor.Request(method: method, uri: URI.init(scheme: "http", hostname: hostname, path: path, query: self.path.query.rawValue), headers: headers, body: body)
    }
}

extension Vapor.Response : Leopard.ResponseRepresentable {
    public func makeResponse() throws -> Lynx.Response {
        var headers = Headers()
        
        for (key, value) in self.headers {
            headers[Lynx.HeaderKey(key.key)] = HeaderValue(value)
        }
        
        return Lynx.Response(status: Lynx.Status(self.status.statusCode), headers: headers, body: Lynx.Body(self.body.bytes ?? []))
    }
}