Get sniff and handler tests passing

Author: quinnj

src/HTTP.jl

@@ -20,7 +20,7 @@ include("client/stream.jl")
 include("client/makerequest.jl")
 include("websockets.jl"); using .WebSockets
 include("server.jl")
-include("handlers.jl")
+include("Handlers.jl"); using .Handlers
 include("statuses.jl")
 
 struct StatusError <: Exception

src/Handlers.jl

@@ -1,6 +1,8 @@
 module Handlers
 
-import ..Request
+export Handler, Middleware, serve, serve!, Router, register!, getroute, getparams, getparam, getcookies
+
+import ..Request, ..Cookies
 
 """
     Handler
@@ -285,8 +287,7 @@ register!(r::Router, path, handler) = register!(r, "*", path, handler)
 const Params = Dict{String, String}
 
 function gethandler(r::Router, req::Request)
-    url = req.uri
-    segments = split(url.path, '/'; keepempty=false)
+    segments = split(req.path, '/'; keepempty=false)
     leaf = match(r.routes, req.method, segments, 1)
     params = Params()
     if leaf isa Leaf
@@ -329,9 +330,9 @@ function (r::Router)(req::Request)
         # matched the path, but method not supported
         return r._405(req)
     else
-        req.context[:route] = route
+        req.route = route
         if !isempty(params)
-            req.context[:params] = params
+            req.params = params
         end
         return handler(req)
     end
@@ -344,7 +345,7 @@ Retrieve the original route registration string for a request after its url has
 matched against a router. Helpful for metric logging to ignore matched variables in
 a path and only see the registered routes.
 """
-getroute(req) = Base.get(req.context, :route, nothing)
+getroute(req) = req.route
 
 """
     HTTP.getparams(req) -> Dict{String, String}
@@ -354,7 +355,7 @@ If a path was registered with a router via `HTTP.register!` like
 "/api/widget/{id}", then the path parameters are available in the request context
 and can be retrieved like `id = HTTP.getparams(req)["id"]`.
 """
-getparams(req) = Base.get(req.context, :params, nothing)
+getparams(req) = req.params
 
 """
     HTTP.getparam(req, name, default=nothing) -> String
@@ -378,8 +379,8 @@ request in the request context. Cookies can then be retrieved by calling
 """
 function cookie_middleware(handler)
     function (req)
-        if !haskey(req.context, :cookies)
-            req.context[:cookies] = Cookies.cookies(req)
+        if req.cookies === nothing
+            req.cookies = Cookies.cookies(req)
         end
         return handler(req)
     end
@@ -393,6 +394,6 @@ are expected to be stored in the `req.context[:cookies]` of the
 request context as implemented in the [`HTTP.Handlers.cookie_middleware`](@ref)
 middleware.
 """
-getcookies(req) = Base.get(() -> Cookie[], req.context, :cookies)
+getcookies(req) = req.cookies === nothing ? Cookies.Cookie[] : req.cookies::Vector{Cookies.Cookie}
 
 end # module Handlers

src/requestresponse.jl

@@ -159,7 +159,11 @@ mutable struct Request <: Message
     allocator::Ptr{aws_allocator}
     ptr::Ptr{aws_http_message}
     inputstream::InputStream # used for outgoing request body
-    body::Union{Nothing, Vector{UInt8}} # only set in server-side request handlers
+    # only set in server-side request handlers
+    body::Union{Nothing, Vector{UInt8}}
+    route::Union{Nothing, String}
+    params::Union{Nothing, Dict{String, String}}
+    cookies::Any # actually Union{Nothing, Vector{Cookie}}
 
     function Request(method, path, headers=nothing, body=nothing, http2::Bool=false, allocator=default_aws_allocator())
         ptr = http2 ?
@@ -177,6 +181,9 @@ mutable struct Request <: Message
             end
             req = new(allocator, ptr)
             req.body = nothing
+            req.route = nothing
+            req.params = nothing
+            req.cookies = nothing
             body !== nothing && setinputstream!(req, body)
             return finalizer(_ -> aws_http_message_release(ptr), req)
         catch
@@ -195,11 +202,12 @@ function Base.getproperty(x::Request, s::Symbol)
             aws_http_message_get_request_method(ptr(x), out) != 0 && return nothing
             return str(out[])
         end
-    elseif s == :path
+    elseif s == :path || s == :target || s == :uri
         out = Ref{aws_byte_cursor}()
         GC.@preserve out begin
             aws_http_message_get_request_path(ptr(x), out) != 0 && return nothing
-            return str(out[])
+            path = str(out[])
+            return s == :uri ? URI(path) : path
         end
     elseif s == :headers
         return Headers(aws_http_message_get_headers(ptr(x)))

src/utils.jl

@@ -38,7 +38,7 @@ Ensure the first character and characters that follow a '-' are uppercase.
 """
 function tocameldash(s::String)
     toUpper = UInt8('A') - UInt8('a')
-    v = Vector{UInt8}(bytes(s))
+    v = Vector{UInt8}(codeunits(s))
     upper = true
     for i = 1:length(v)
         @inbounds b = v[i]

test/handlers.jl

@@ -46,10 +46,10 @@ using HTTP, Test
     HTTP.register!(r, "/api/widgets/{id}", req -> HTTP.getparam(req, "id"))
     @test r(HTTP.Request("GET", "/api/widgets/11")) == "11"
 
-    HTTP.register!(r, "/api/widgets/{name}", req -> (req.context[:params]["name"], HTTP.getroute(req)))
+    HTTP.register!(r, "/api/widgets/{name}", req -> (HTTP.getparam(req, "name"), HTTP.getroute(req)))
     @test r(HTTP.Request("GET", "/api/widgets/11")) == ("11", "/api/widgets/{name}")
 
-    HTTP.register!(r, "/api/widgets/acme/{id:[a-z]+}", req -> req.context[:params]["id"])
+    HTTP.register!(r, "/api/widgets/acme/{id:[a-z]+}", req -> HTTP.getparam(req, "id"))
     called[] = false
     @test r(HTTP.Request("GET", "/api/widgets/acme/11")) == 0
     @test !called[]

test/runtests.jl

@@ -3,7 +3,28 @@ using Test, HTTP, URIs, JSON
 const httpbin = get(ENV, "JULIA_TEST_HTTPBINGO_SERVER", "httpbingo.julialang.org")
 isok(r) = r.status == 200
 
+# Core.eval(Base, :(function unsafe_copyto!(dest::Base.MemoryRef{T}, src::Base.MemoryRef{T}, n) where {T}
+#     Base.@_terminates_globally_notaskstate_meta
+#     n == 0 && return dest
+#     @show n
+#     @boundscheck Base.memoryref(dest, n), Base.memoryref(src, n)
+#     if isbitstype(T)
+#         tdest = Base.@_gc_preserve_begin dest
+#         tsrc = Base.@_gc_preserve_begin src
+#         pdest = unsafe_convert(Ptr{Cvoid}, dest)
+#         psrc = unsafe_convert(Ptr{Cvoid}, src)
+#         Base.memmove(pdest, psrc, Base.aligned_sizeof(T) * n)
+#         Base.@_gc_preserve_end tdest
+#         Base.@_gc_preserve_end tsrc
+#     else
+#         ccall(:jl_genericmemory_copyto, Cvoid, (Any, Ptr{Cvoid}, Any, Ptr{Cvoid}, Int), dest.mem, dest.ptr_or_offset, src.mem, src.ptr_or_offset, Int(n))
+#     end
+#     return dest
+# end))
+
 include("utils.jl")
+include("sniff.jl")
+include("multipart.jl")
 include("client.jl")
 include("handlers.jl")
 include("server.jl")