reactor.ipc.netty.http.server.SimpleHttpServerRoutes Maven / Gradle / Ivy

Go to download
package reactor.ipc.netty.http.server;

import com.stony.reactor.jersey.MimeType;
import com.stony.reactor.jersey.MimeTypeUtil;
import io.netty.handler.codec.http.HttpMethod;
import org.reactivestreams.Publisher;
import reactor.core.Exceptions;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * reactor-netty-ext
 * reactor.ipc.netty.http.server
 *
 * @author stony
 * @version 下午5:08
 * @since 2018/2/8
 */
public class SimpleHttpServerRoutes implements HttpServerRoutes {

    BiFunction> handler;
    private volatile Path staticDirectory;

    private SimpleHttpServerRoutes(BiFunction> handler) {
        this.handler = handler;
    }

    public static HttpServerRoutes newRoutes(BiFunction> handler) {
        return new SimpleHttpServerRoutes(handler);
    }

    private final CopyOnWriteArrayList handlers = new CopyOnWriteArrayList<>();

    @Override
    public HttpServerRoutes get(String path, BiFunction> handler) {
        return route(SimpleHttpPredicate.get(path), handler);
    }

    @Override
    public HttpServerRoutes directory(String uri, Path directory,
                                      Function interceptor) {
        Objects.requireNonNull(directory, "directory");
        this.staticDirectory = directory;
        return route(HttpPredicate.prefix(uri), (req, resp) -> {

            String prefix = URI.create(req.uri())
                    .getPath()
                    .replaceFirst(uri, "");

            if (prefix.charAt(0) == '/') {
                prefix = prefix.substring(1);
            }

            Path p = directory.resolve(prefix);
            if (Files.isReadable(p)) {

                if (interceptor != null) {
                    return interceptor.apply(resp)
                            .sendFile(p);
                }
                return resp.sendFile(p);
            }

            return resp.sendNotFound();
        });
    }

    @Override
    public HttpServerRoutes route(Predicate condition,
                                  BiFunction> handler) {
        Objects.requireNonNull(condition, "condition");
        Objects.requireNonNull(handler, "handler");

        if (condition instanceof HttpPredicate) {
            handlers.add(new HttpRouteHandler(condition, handler, (HttpPredicate) condition));
        } else if (condition instanceof SimpleHttpPredicate) {
            handlers.add(new HttpRouteHandler(condition, handler, (SimpleHttpPredicate) condition));
        } else {
            handlers.add(new HttpRouteHandler(condition, handler, null));
        }
        return this;
    }

    @Override
    public Publisher apply(HttpServerRequest request, HttpServerResponse response) {
        final Iterator iterator = handlers.iterator();
        HttpRouteHandler cursor;
        try {
            while (iterator.hasNext()) {
                cursor = iterator.next();
                if (cursor.test(request)) {
                    return cursor.apply(request, response);
                }
            }
            MimeType type = MimeTypeUtil.getInstance().getMimeTypeByUri(request.uri());
            if(type != null) {
                Path p = staticDirectory.resolve(type.getFilePath());
                if (Files.isReadable(p)) {
//                return response.header("Content-Type", type.getContentType()).sendFile(p);
                    return response.sendFile(p);
                }
//            else {
//                return response.status(404).header("Content-Type", "text/plan; charset=UTF-8").send();
//            }
            }
            if (handler != null) {
                return handler.apply(request, response);
            }
        } catch (Throwable t) {
            Exceptions.throwIfFatal(t);
            return Mono.error(t); //500
        }
        return response.sendNotFound();
    }

    /**
     */
    static final class HttpRouteHandler
            implements BiFunction>,
            Predicate {

        final Predicate condition;
        final BiFunction>
                handler;
        final Function> resolver;

        HttpRouteHandler(Predicate condition,
                         BiFunction> handler,
                         Function> resolver) {
            this.condition = Objects.requireNonNull(condition, "condition");
            this.handler = Objects.requireNonNull(handler, "handler");
            this.resolver = resolver;
        }

        @Override
        public Publisher apply(HttpServerRequest request,
                                     HttpServerResponse response) {
            return handler.apply(request.paramsResolver(resolver), response);
        }

        @Override
        public boolean test(HttpServerRequest o) {
            return condition.test(o);
        }
    }
}