mirror of
https://github.com/apple/swift-nio-http2
synced 2026-11-22 04:30:43 +00:00
Motivation: This is the beginning of removing the dependency on `nghttp2`. Modifications: I've added a new library target, `NIOHPACK`, which contains all the necessary pieces to implement HPACK encoding as specified in RFC 7541. There are unit tests exercising all the code and some additional edge cases around integer encoding, along with some performance tests for the Huffman encode/decode process. The latter currently takes longer to decode than to encode, which is worrying, but this is only really noticeable when encoding > 16KB strings as a rule; therefore I've decided not to pull out the optimization hammer just yet. Included in the unit tests are the inputs and outputs from all the examples in RFC 7541 and RFC 7540. I've tried to match the coding style from the repo, but some of my own idioms may have crept in here & there. Please let me know if you see anything wrong in that regard. Currently the static header table and Huffman encoding tables are implemented as Swift `let`s. For the static header table that's ok (only 62 entries), but the Huffman table is huge. I'm debating whether it's worth having that in a plain C file somewhere, but I'm not sure what the tradeoffs are vs. performance. Right now it seems to only affect compilation time, but I may be wrong. Result: In general, nothing will change: nothing in NIOHTTP2 is using this library yet. That part is what I'm working on now.
129 lines
5.0 KiB
Swift
129 lines
5.0 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the SwiftNIO open source project
|
|
//
|
|
// Copyright (c) 2017-2018 Apple Inc. and the SwiftNIO project authors
|
|
// Licensed under Apache License v2.0
|
|
//
|
|
// See LICENSE.txt for license information
|
|
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// This example server currently does not know how to negotiate HTTP/2. That will come in a future enhancement. For now, you can
|
|
// hit it with curl like so: curl --http2-prior-knowledge http://localhost:8888/
|
|
|
|
|
|
import NIO
|
|
import NIOHTTP1
|
|
import NIOHTTP2
|
|
|
|
final class HTTP1TestServer: ChannelInboundHandler {
|
|
public typealias InboundIn = HTTPServerRequestPart
|
|
public typealias OutboundOut = HTTPServerResponsePart
|
|
|
|
public func channelRead(ctx: ChannelHandlerContext, data: NIOAny) {
|
|
guard case .end = self.unwrapInboundIn(data) else {
|
|
return
|
|
}
|
|
|
|
ctx.channel.getOption(option: HTTP2StreamChannelOptions.streamID).then { (streamID) -> EventLoopFuture<Void> in
|
|
var headers = HTTPHeaders()
|
|
headers.add(name: "content-length", value: "5")
|
|
headers.add(name: "x-stream-id", value: String(streamID.networkStreamID!))
|
|
ctx.channel.write(self.wrapOutboundOut(HTTPServerResponsePart.head(HTTPResponseHead(version: .init(major: 2, minor: 0), status: .ok, headers: headers))), promise: nil)
|
|
|
|
var buffer = ctx.channel.allocator.buffer(capacity: 12)
|
|
buffer.write(staticString: "hello")
|
|
ctx.channel.write(self.wrapOutboundOut(HTTPServerResponsePart.body(.byteBuffer(buffer))), promise: nil)
|
|
return ctx.channel.writeAndFlush(self.wrapOutboundOut(HTTPServerResponsePart.end(nil)))
|
|
}.whenComplete {
|
|
ctx.close(promise: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// First argument is the program path
|
|
let arguments = CommandLine.arguments
|
|
let arg1 = arguments.dropFirst().first
|
|
let arg2 = arguments.dropFirst().dropFirst().first
|
|
let arg3 = arguments.dropFirst().dropFirst().dropFirst().first
|
|
|
|
let defaultHost = "::1"
|
|
let defaultPort: Int = 8888
|
|
let defaultHtdocs = "/dev/null/"
|
|
|
|
enum BindTo {
|
|
case ip(host: String, port: Int)
|
|
case unixDomainSocket(path: String)
|
|
}
|
|
|
|
let htdocs: String
|
|
let bindTarget: BindTo
|
|
switch (arg1, arg1.flatMap { Int($0) }, arg2, arg2.flatMap { Int($0) }, arg3) {
|
|
case (.some(let h), _ , _, .some(let p), let maybeHtdocs):
|
|
/* second arg an integer --> host port [htdocs] */
|
|
bindTarget = .ip(host: h, port: p)
|
|
htdocs = maybeHtdocs ?? defaultHtdocs
|
|
case (_, .some(let p), let maybeHtdocs, _, _):
|
|
/* first arg an integer --> port [htdocs] */
|
|
bindTarget = .ip(host: defaultHost, port: p)
|
|
htdocs = maybeHtdocs ?? defaultHtdocs
|
|
case (.some(let portString), .none, let maybeHtdocs, .none, .none):
|
|
/* couldn't parse as number --> uds-path [htdocs] */
|
|
bindTarget = .unixDomainSocket(path: portString)
|
|
htdocs = maybeHtdocs ?? defaultHtdocs
|
|
default:
|
|
htdocs = defaultHtdocs
|
|
bindTarget = BindTo.ip(host: defaultHost, port: defaultPort)
|
|
}
|
|
|
|
let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
|
|
let bootstrap = ServerBootstrap(group: group)
|
|
// Specify backlog and enable SO_REUSEADDR for the server itself
|
|
.serverChannelOption(ChannelOptions.backlog, value: 256)
|
|
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
|
|
|
|
// Set the handlers that are applied to the accepted Channels
|
|
.childChannelInitializer { channel in
|
|
return channel.pipeline.add(handler: HTTP2Parser(mode: .server)).then {
|
|
let multiplexer = HTTP2StreamMultiplexer { (channel, streamID) -> EventLoopFuture<Void> in
|
|
return channel.pipeline.add(handler: HTTP2ToHTTP1ServerCodec(streamID: streamID)).then { () -> EventLoopFuture<Void> in
|
|
channel.pipeline.add(handler: HTTP1TestServer())
|
|
}
|
|
}
|
|
|
|
return channel.pipeline.add(handler: multiplexer)
|
|
}
|
|
}
|
|
|
|
// Enable TCP_NODELAY and SO_REUSEADDR for the accepted Channels
|
|
.childChannelOption(ChannelOptions.socket(IPPROTO_TCP, TCP_NODELAY), value: 1)
|
|
.childChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
|
|
.childChannelOption(ChannelOptions.maxMessagesPerRead, value: 1)
|
|
|
|
defer {
|
|
try! group.syncShutdownGracefully()
|
|
}
|
|
|
|
print("htdocs = \(htdocs)")
|
|
|
|
let channel = try { () -> Channel in
|
|
switch bindTarget {
|
|
case .ip(let host, let port):
|
|
return try bootstrap.bind(host: host, port: port).wait()
|
|
case .unixDomainSocket(let path):
|
|
return try bootstrap.bind(unixDomainSocketPath: path).wait()
|
|
}
|
|
}()
|
|
|
|
print("Server started and listening on \(channel.localAddress!), htdocs path \(htdocs)")
|
|
|
|
// This will never unblock as we don't close the ServerChannel
|
|
try channel.closeFuture.wait()
|
|
|
|
print("Server closed")
|