@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpMessage msg)
throws Exception { // 1
// Request header 처리
if (msg instanceof HttpRequest) { // 2
this.request = (HttpRequest) msg; // 3
if (HttpHeaders.is100ContinueExpected(request)) {
send100Continue(ctx);
}
HttpHeaders headers = request.headers(); // 4
if (!headers.isEmpty()) {
for (Map.Entry<String, String> h : headers) {
String key = h.getKey();
if (usingHeader.contains(key)) { // 5
reqData.put(key, h.getValue()); // 6
}
}
}
reqData.put("REQUEST_URI", request.getUri()); // 7
reqData.put("REQUEST_METHOD", request.getMethod().name()); // 8
}
if (msg instanceof HttpContent) { // 9
HttpContent httpContent = (HttpContent) msg; // 10
ByteBuf content = httpContent.content(); // 11
if (msg instanceof LastHttpContent) { // 12
System.out.println("LastHttpContent message received!!" + request.getUri());
LastHttpContent trailer = (LastHttpContent) msg;
readPostData(); // 13
ApiRequest service = ServiceDispatcher.dispatch(reqData); // 14
try {
service.executeService(); // 15
apiResult = service.getApiResult(); // 16
} finally {
reqData.clear();
}
if (!writeResponse(trailer, ctx)) { // 17
ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
}
reset();
}
}
}
@Override
public void channelRead0(final ChannelHandlerContext ctx, HttpRequest req) throws Exception {
if (req.getUri().equals("/hello")) {
ctx.executor().schedule(new HelloWorldRunnable(ctx), 10, TimeUnit.SECONDS);
} else {
ctx.fireChannelRead(req);
}
}
@Override
protected void doGet(ChannelHandlerContext ctx, HttpRequest httpReq) {
getCount++;
processTime();
QueryStringDecoder reqDecoder = new QueryStringDecoder(httpReq.getUri());
String data = reqDecoder.parameters().get("data").get(0);
Payload payload = JSONSerializer.INSTANCE.fromString(data, Payload.class);
writeJSON(ctx, httpReq, payload);
this.writeContent(ctx, httpReq, "do get", "text/plain");
}
public static ResteasyUriInfo extractUriInfo(
HttpRequest request, String contextPath, String protocol) {
String host = HttpHeaders.getHost(request, "unknown");
String uri = request.getUri();
String uriString = protocol + "://" + host + uri;
URI absoluteURI = URI.create(uriString);
URI noQuery = UriBuilder.fromUri(uriString).replaceQuery(null).build();
return new ResteasyUriInfo(uriString, absoluteURI.getRawQuery(), contextPath);
}
/**
* Get the mover channel for a certain HTTP request. The mover channel is identified by UUID
* generated upon mover start and sent back to the door as a part of the address info.
*
* @param request HttpRequest that was sent by the client
* @param exclusive True if the mover channel exclusively is to be opened in exclusive mode. False
* if the mover channel can be shared with other requests.
* @return Mover channel for specified UUID
* @throws IllegalArgumentException Request did not include UUID or no mover channel found for
* UUID in the request
*/
private NettyTransferService<HttpProtocolInfo>.NettyMoverChannel open(
HttpRequest request, boolean exclusive) throws IllegalArgumentException, URISyntaxException {
QueryStringDecoder queryStringDecoder = new QueryStringDecoder(request.getUri());
Map<String, List<String>> params = queryStringDecoder.parameters();
if (!params.containsKey(HttpTransferService.UUID_QUERY_PARAM)) {
if (!request.getUri().equals("/favicon.ico")) {
_logger.error(
"Received request without UUID in the query " + "string. Request-URI was {}",
request.getUri());
}
throw new IllegalArgumentException("Query string does not include any UUID.");
}
List<String> uuidList = params.get(HttpTransferService.UUID_QUERY_PARAM);
if (uuidList.isEmpty()) {
throw new IllegalArgumentException("UUID parameter does not include any value.");
}
UUID uuid = UUID.fromString(uuidList.get(0));
NettyTransferService<HttpProtocolInfo>.NettyMoverChannel file =
_server.openFile(uuid, exclusive);
if (file == null) {
throw new IllegalArgumentException(
"Request is no longer valid. " + "Please resubmit to door.");
}
URI uri = new URI(request.getUri());
FsPath requestedFile = FsPath.create(uri.getPath());
FsPath transferFile = FsPath.create(file.getProtocolInfo().getPath());
if (!requestedFile.equals(transferFile)) {
_logger.warn(
"Received an illegal request for file {}, while serving {}", requestedFile, transferFile);
throw new IllegalArgumentException(
"The file you specified does " + "not match the UUID you specified!");
}
_files.add(file);
return file;
}
@Override
public Context process(final HttpObject request, final Context context) {
if (request instanceof HttpRequest) {
final HttpRequest httpRequest = (HttpRequest) request;
final QueryStringDecoder queryStringDecoder = new QueryStringDecoder(httpRequest.getUri());
context.getQueryParams().putAll(queryStringDecoder.parameters());
context.getCookies().putAll(readCookie(httpRequest));
}
return context;
}
/**
* Returns the route URI for the current request
*
* @param request HttpRequest which contains the request URI of the current session
* @return Returns the route
* @throws URISyntaxException
*/
public TrackingType setTrackingType(HttpRequest request) throws URISyntaxException {
URI uri = new URI(request.getUri());
if (uri.getPath().startsWith("/trackingPoint")) {
return TrackingType.TRACKING_POINT;
} else if (uri.getPath().startsWith("/startTracking")) {
return TrackingType.START_TRACKING;
} else if (uri.getPath().startsWith("/stopTracking")) {
return TrackingType.STOP_TRACKING;
} else {
return TrackingType.UNKNOWN;
}
}
private static boolean isRequestTo(HttpRequest request, String uri) {
URI decodedUri;
try {
decodedUri = new URI(request.getUri());
} catch (URISyntaxException e) {
return false;
}
return HttpVersion.HTTP_1_1.equals(request.getProtocolVersion())
&& USER_AGENT.equals(request.getHeader(HttpHeaders.Names.USER_AGENT))
&& HttpMethod.POST.equals(request.getMethod())
&& uri.equals(decodedUri.getPath());
}
public void messageReceived(ChannelHandlerContext ctx, Object o) throws Exception {
if (o instanceof HttpRequest) { // DefaultHttpRequest ) {
queue.add((HttpRequest) o);
} else if (o instanceof LastHttpContent) {
HttpRequest req = queue.remove();
req.getMethod();
req.getUri();
req.headers();
LastHttpContent content = (LastHttpContent) o;
ByteBuf buf = content.content();
if (buf.readableBytes() > 0) {
Gson gson = GsonFactory.createBuilder().create();
Reader in = new InputStreamReader(new ByteBufInputStream(buf), "utf-8");
Object v =
gson.fromJson(in, Class.forName("com.logbook.logbook.resources.logs.LogEntryDTO"));
System.out.println("v = " + v);
}
System.out.println(
req.getMethod() + " " + req.getUri() + " -- " + buf.readableBytes() + " bytes");
HttpResponse r = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
r.headers().add("Content-Length", "0");
ctx.write(r);
} else {
System.out.println("o = " + o + " : " + o.getClass());
}
}
@Override
public void handleWebRequest(
ChannelHandlerContext ctx,
HttpRequest nettyRequest,
HttpFileUpload upload,
Set<HttpCookie> cookiesToAdd)
throws IOException {
NettyHttpRequest request =
new NettyHttpRequest(nettyRequest, parentHandler.getWebServer().getLog());
NettyHttpResponse response = new NettyHttpResponse(ctx, extraHttpContentHeaders);
response.addCookies(cookiesToAdd);
DefaultFullHttpResponse res;
try {
requestHandler.handle(request, upload, response);
res =
new DefaultFullHttpResponse(
HttpVersion.HTTP_1_1,
HttpResponseStatus.valueOf(response.getResponseCode()),
response.getChannelBuffer());
String contentType = response.getContentType();
if (contentType != null) {
addHeader(res, HttpHeaders.Names.CONTENT_TYPE, contentType);
}
parentHandler.addHttpResponseHeaders(res, response.getContentHeaders());
parentHandler.sendHttpResponse(ctx, nettyRequest, res, true, false);
parentHandler
.getWebServer()
.getLog()
.debug("Dynamic content handler for %s completed", uriPrefix);
} catch (Throwable e) {
parentHandler
.getWebServer()
.getLog()
.error(
String.format(
"Error while handling dynamic web server request %s", nettyRequest.getUri()),
e);
parentHandler.sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
}
}
@Override
public boolean preCall(HttpRequest request, HttpResponder responder, HandlerInfo handlerInfo) {
HTTPMonitoringEvent httpMonitoringEvent = new HTTPMonitoringEvent();
httpMonitoringEvent.setTimestamp(System.currentTimeMillis());
httpMonitoringEvent.setStartNanoTime(System.nanoTime());
if (serviceClass == null) {
Method method = handlerInfo.getMethod();
Class<?> serviceClass = method.getDeclaringClass();
this.serviceClass = serviceClass.getName();
serviceName = serviceClass.getSimpleName();
serviceMethod = method.getName();
if (serviceClass.isAnnotationPresent(Path.class)) {
Path path = serviceClass.getAnnotation(Path.class);
servicePath = path.value();
}
}
httpMonitoringEvent.setServiceClass(serviceClass);
httpMonitoringEvent.setServiceName(serviceName);
httpMonitoringEvent.setServiceMethod(serviceMethod);
httpMonitoringEvent.setRequestUri(request.getUri());
httpMonitoringEvent.setServiceContext(servicePath);
HttpHeaders httpHeaders = request.headers();
httpMonitoringEvent.setHttpMethod(request.getMethod().name());
httpMonitoringEvent.setContentType(httpHeaders.get(HttpHeaders.Names.CONTENT_TYPE));
String contentLength = httpHeaders.get(HttpHeaders.Names.CONTENT_LENGTH);
if (contentLength != null) {
httpMonitoringEvent.setRequestSizeBytes(Long.parseLong(contentLength));
}
httpMonitoringEvent.setReferrer(httpHeaders.get(HttpHeaders.Names.REFERER));
handlerInfo.setAttribute(MONITORING_EVENT, httpMonitoringEvent);
return true;
}
private SpdySynStreamFrame createSynStreamFrame(HttpMessage httpMessage) throws Exception {
boolean chunked = httpMessage.isChunked();
// Get the Stream-ID, Associated-To-Stream-ID, Priority, URL, and scheme from the headers
int streamID = SpdyHttpHeaders.getStreamID(httpMessage);
int associatedToStreamID = SpdyHttpHeaders.getAssociatedToStreamID(httpMessage);
byte priority = SpdyHttpHeaders.getPriority(httpMessage);
String URL = SpdyHttpHeaders.getUrl(httpMessage);
String scheme = SpdyHttpHeaders.getScheme(httpMessage);
SpdyHttpHeaders.removeStreamID(httpMessage);
SpdyHttpHeaders.removeAssociatedToStreamID(httpMessage);
SpdyHttpHeaders.removePriority(httpMessage);
SpdyHttpHeaders.removeUrl(httpMessage);
SpdyHttpHeaders.removeScheme(httpMessage);
// The Connection, Keep-Alive, Proxy-Connection, and Transfer-Encoding
// headers are not valid and MUST not be sent.
httpMessage.removeHeader(HttpHeaders.Names.CONNECTION);
httpMessage.removeHeader("Keep-Alive");
httpMessage.removeHeader("Proxy-Connection");
httpMessage.removeHeader(HttpHeaders.Names.TRANSFER_ENCODING);
SpdySynStreamFrame spdySynStreamFrame =
new DefaultSpdySynStreamFrame(streamID, associatedToStreamID, priority);
// Unfold the first line of the message into name/value pairs
if (httpMessage instanceof HttpRequest) {
HttpRequest httpRequest = (HttpRequest) httpMessage;
SpdyHeaders.setMethod(spdyVersion, spdySynStreamFrame, httpRequest.getMethod());
SpdyHeaders.setUrl(spdyVersion, spdySynStreamFrame, httpRequest.getUri());
SpdyHeaders.setVersion(spdyVersion, spdySynStreamFrame, httpMessage.getProtocolVersion());
}
if (httpMessage instanceof HttpResponse) {
HttpResponse httpResponse = (HttpResponse) httpMessage;
SpdyHeaders.setStatus(spdyVersion, spdySynStreamFrame, httpResponse.getStatus());
SpdyHeaders.setUrl(spdyVersion, spdySynStreamFrame, URL);
spdySynStreamFrame.setUnidirectional(true);
}
// Replace the HTTP host header with the SPDY host header
if (spdyVersion >= 3) {
String host = HttpHeaders.getHost(httpMessage);
httpMessage.removeHeader(HttpHeaders.Names.HOST);
SpdyHeaders.setHost(spdySynStreamFrame, host);
}
// Set the SPDY scheme header
if (scheme == null) {
scheme = "https";
}
SpdyHeaders.setScheme(spdyVersion, spdySynStreamFrame, scheme);
// Transfer the remaining HTTP headers
for (Map.Entry<String, String> entry : httpMessage.getHeaders()) {
spdySynStreamFrame.addHeader(entry.getKey(), entry.getValue());
}
if (chunked) {
currentStreamID = streamID;
spdySynStreamFrame.setLast(false);
} else {
spdySynStreamFrame.setLast(httpMessage.getContent().readableBytes() == 0);
}
return spdySynStreamFrame;
}
@Override
public String uri() {
return request.getUri();
}
/**
* Call the appropriate handler for handling the httprequest. 404 if path is not found. 405 if
* path is found but httpMethod does not match what's configured.
*
* @param request instance of {@code HttpRequest}
* @param responder instance of {@code HttpResponder} to handle the request.
* @return HttpMethodInfo object, null if urlRewriter rewrite returns false, also when method
* cannot be invoked.
* @throws HandlerException If URL rewriting fails
*/
public HttpMethodInfoBuilder getDestinationMethod(HttpRequest request, HttpResponder responder)
throws HandlerException {
if (urlRewriter != null) {
try {
request.setUri(URI.create(request.getUri()).normalize().toString());
if (!urlRewriter.rewrite(request, responder)) {
return null;
}
} catch (Throwable t) {
log.error("Exception thrown during rewriting of uri {}", request.getUri(), t);
throw new HandlerException(
HttpResponseStatus.INTERNAL_SERVER_ERROR,
String.format("Caught exception processing request. Reason: %s", t.getMessage()));
}
}
String acceptHeaderStr = request.headers().get(HttpHeaders.Names.ACCEPT);
List<String> acceptHeader =
(acceptHeaderStr != null)
? Arrays.asList(acceptHeaderStr.split("\\s*,\\s*"))
.stream()
.map(mediaType -> mediaType.split("\\s*;\\s*")[0])
.collect(Collectors.toList())
: null;
String contentTypeHeaderStr = request.headers().get(HttpHeaders.Names.CONTENT_TYPE);
// Trim specified charset since UTF-8 is assumed
String contentTypeHeader =
(contentTypeHeaderStr != null) ? contentTypeHeaderStr.split("\\s*;\\s*")[0] : null;
try {
String path = URI.create(request.getUri()).normalize().getPath();
List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>>
routableDestinations = patternRouter.getDestinations(path);
List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>> matchedDestinations =
getMatchedDestination(routableDestinations, request.getMethod(), path);
if (!matchedDestinations.isEmpty()) {
PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel> matchedDestination =
matchedDestinations
.stream()
.filter(
matchedDestination1 -> {
return matchedDestination1
.getDestination()
.matchConsumeMediaType(contentTypeHeader)
&& matchedDestination1
.getDestination()
.matchProduceMediaType(acceptHeader);
})
.findFirst()
.get();
HttpResourceModel httpResourceModel = matchedDestination.getDestination();
// Call preCall method of handler interceptors.
boolean terminated = false;
ServiceMethodInfo serviceMethodInfo =
new ServiceMethodInfo(
httpResourceModel.getMethod().getDeclaringClass().getName(),
httpResourceModel.getMethod());
for (Interceptor interceptor : interceptors) {
if (!interceptor.preCall(request, responder, serviceMethodInfo)) {
// Terminate further request processing if preCall returns false.
terminated = true;
break;
}
}
// Call httpresource handle method, return the HttpMethodInfo Object.
if (!terminated) {
// Wrap responder to make post hook calls.
responder = new WrappedHttpResponder(responder, interceptors, request, serviceMethodInfo);
return HttpMethodInfoBuilder.getInstance()
.httpResourceModel(httpResourceModel)
.httpRequest(request)
.httpResponder(responder)
.requestInfo(
matchedDestination.getGroupNameValues(), contentTypeHeader, acceptHeader);
}
} else if (!routableDestinations.isEmpty()) {
// Found a matching resource but could not find the right HttpMethod so return 405
throw new HandlerException(HttpResponseStatus.METHOD_NOT_ALLOWED, request.getUri());
} else {
throw new HandlerException(
HttpResponseStatus.NOT_FOUND,
String.format("Problem accessing: %s. Reason: Not Found", request.getUri()));
}
} catch (NoSuchElementException ex) {
throw new HandlerException(
HttpResponseStatus.UNSUPPORTED_MEDIA_TYPE,
String.format("Problem accessing: %s. Reason: Unsupported Media Type", request.getUri()),
ex);
}
return null;
}
@Override
public boolean isHandledBy(HttpRequest req) {
return req.getUri().startsWith(uriPrefix);
}
@Override
public String getUrl() {
return req.getUri();
}
@Override
public void messageReceived(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
if (msg instanceof HttpRequest) {
HttpRequest request = this.request = (HttpRequest) msg;
URI uri = new URI(request.getUri());
if (!uri.getPath().startsWith("/form")) {
// Write Menu
writeMenu(ctx);
return;
}
responseContent.setLength(0);
responseContent.append("WELCOME TO THE WILD WILD WEB SERVER\r\n");
responseContent.append("===================================\r\n");
responseContent.append("VERSION: " + request.getProtocolVersion().text() + "\r\n");
responseContent.append("REQUEST_URI: " + request.getUri() + "\r\n\r\n");
responseContent.append("\r\n\r\n");
// new getMethod
for (Entry<String, String> entry : request.headers()) {
responseContent.append("HEADER: " + entry.getKey() + '=' + entry.getValue() + "\r\n");
}
responseContent.append("\r\n\r\n");
// new getMethod
Set<Cookie> cookies;
String value = request.headers().get(COOKIE);
if (value == null) {
cookies = Collections.emptySet();
} else {
cookies = CookieDecoder.decode(value);
}
for (Cookie cookie : cookies) {
responseContent.append("COOKIE: " + cookie + "\r\n");
}
responseContent.append("\r\n\r\n");
QueryStringDecoder decoderQuery = new QueryStringDecoder(request.getUri());
Map<String, List<String>> uriAttributes = decoderQuery.parameters();
for (Entry<String, List<String>> attr : uriAttributes.entrySet()) {
for (String attrVal : attr.getValue()) {
responseContent.append("URI: " + attr.getKey() + '=' + attrVal + "\r\n");
}
}
responseContent.append("\r\n\r\n");
// if GET Method: should not try to create a HttpPostRequestDecoder
if (request.getMethod().equals(HttpMethod.GET)) {
// GET Method: should not try to create a HttpPostRequestDecoder
// So stop here
responseContent.append("\r\n\r\nEND OF GET CONTENT\r\n");
writeResponse(ctx.channel());
return;
}
try {
decoder = new HttpPostRequestDecoder(factory, request);
} catch (ErrorDataDecoderException e1) {
e1.printStackTrace();
responseContent.append(e1.getMessage());
writeResponse(ctx.channel());
ctx.channel().close();
return;
}
readingChunks = HttpHeaders.isTransferEncodingChunked(request);
responseContent.append("Is Chunked: " + readingChunks + "\r\n");
responseContent.append("IsMultipart: " + decoder.isMultipart() + "\r\n");
if (readingChunks) {
// Chunk version
responseContent.append("Chunks: ");
readingChunks = true;
}
}
// check if the decoder was constructed before
// if not it handles the form get
if (decoder != null) {
if (msg instanceof HttpContent) {
// New chunk is received
HttpContent chunk = (HttpContent) msg;
try {
decoder.offer(chunk);
} catch (ErrorDataDecoderException e1) {
e1.printStackTrace();
responseContent.append(e1.getMessage());
writeResponse(ctx.channel());
ctx.channel().close();
return;
}
responseContent.append('o');
// example of reading chunk by chunk (minimize memory usage due to
// Factory)
readHttpDataChunkByChunk();
// example of reading only if at the end
if (chunk instanceof LastHttpContent) {
writeResponse(ctx.channel());
readingChunks = false;
reset();
}
}
}
}