Example usage for io.vertx.core MultiMap getAll

List of usage examples for io.vertx.core MultiMap getAll

  1. HOME
  2. Java
  3. io.vertx
  4. io.vertx.core.*
  5. MultiMap
  6. getAll

Introduction

In this page you can find the example usage for io.vertx.core MultiMap getAll.

Prototype

@GenIgnore(GenIgnore.PERMITTED_TYPE)
List<String> getAll(CharSequence name);

Source Link

Document

Like #getAll(String) but accepting a CharSequence as a parameter

Usage

From source file:co.runrightfast.core.utils.VertxUtils.java

License:Apache License

static JsonObject toJsonObject(@NonNull final MultiMap map) {
    if (map.isEmpty()) {
        return EMPTY_OBJECT;
    }//from   www  . ja v a  2  s .co  m

    final JsonObjectBuilder json = Json.createObjectBuilder();
    map.names().stream().forEach(name -> {
        final List<String> values = map.getAll(name);
        if (values.size() == 1) {
            json.add(name, values.get(0));
        } else {
            json.add(name, JsonUtils.toJsonArray(values));
        }
    });
    return json.build();
}

From source file:io.nitor.api.backend.proxy.Proxy.java

License:Apache License

public void handle(RoutingContext routingContext) {
    final HttpServerRequest sreq = routingContext.request();
    final boolean isTls = isOrigReqHttps || "https".equals(routingContext.request().scheme());
    final boolean isHTTP2 = routingContext.request().version() == HTTP_2;
    final String chost = getRemoteAddress(routingContext);
    final ProxyTracer tracer = tracerFactory.get();
    String reqId = sreq.headers().get(requestIdHeader);
    boolean hadRequestId = reqId != null;
    if (reqId == null) {
        reqId = Long.toString(requestId.getAndIncrement());
    }//from  w ww .j  a  v a2 s .  c  o m
    tracer.incomingRequestStart(routingContext, isTls, isHTTP2, chost, reqId);
    if (!hadRequestId) {
        sreq.headers().add(requestIdHeader, reqId);
    }

    HttpServerResponse sres = sreq.response();
    sres.exceptionHandler(tracer::outgoingResponseException);
    routingContext.addHeadersEndHandler(tracer::outgoingResponseHeadersEnd);
    sres.bodyEndHandler(tracer::outgoingResponseBodyEnd);
    if (!isHTTP2) {
        sres.headers().add("keep-alive", keepAliveHeaderValue);
        sres.headers().add("connection", "keep-alive");
    }
    sreq.exceptionHandler(t -> {
        tracer.incomingRequestException(t);
        routingContext.fail(new ProxyException(500, RejectReason.incomingRequestFail, t));
    });

    final State state = new State();

    targetResolver.resolveNextHop(routingContext, nextHop -> {
        if (nextHop == null) {
            NullPointerException e = new NullPointerException("nextHop must not be null");
            tracer.incomingRequestException(e);
            throw e;
        }
        tracer.nextHopResolved(nextHop);

        MultiMap sreqh = sreq.headers();
        String origHost = null;
        if (isHTTP2) {
            origHost = sreqh.get(":authority");
        }
        if (origHost == null) {
            origHost = sreqh.get("Host");
        }
        if (origHost == null) {
            ProxyException e = new ProxyException(400, RejectReason.noHostHeader, null);
            tracer.incomingRequestException(e);
            routingContext.fail(e);
            return;
        }
        boolean isWebsocket = !isHTTP2 && "websocket".equals(sreqh.get("upgrade"));
        if (isWebsocket) {
            MultiMap creqh = new CaseInsensitiveHeaders();
            propagateRequestHeaders(isTls, chost, sreqh, origHost, creqh);
            if (nextHop.hostHeader != null) {
                creqh.set("Host", nextHop.hostHeader);
            } else {
                creqh.remove("Host");
            }
            tracer.outgoingWebsocketInitial(creqh);
            client.websocket(nextHop.socketPort, nextHop.socketHost, nextHop.uri, creqh, cws -> {
                // lol no headers copied
                final boolean[] isClosed = { false };
                ServerWebSocket sws = sreq.upgrade();
                tracer.websocketEstablished();
                for (final WebSocketBase[] pair : new WebSocketBase[][] { { sws, cws }, { cws, sws } }) {
                    pair[0].frameHandler(pair[1]::writeFrame).closeHandler(v -> {
                        if (!isClosed[0]) {
                            tracer.establishedWebsocketClosed();
                            isClosed[0] = true;
                            pair[1].close();
                        }
                    }).exceptionHandler(t -> {
                        tracer.establishedWebsocketException(t);
                        t.printStackTrace();
                        if (!isClosed[0]) {
                            isClosed[0] = true;
                            try {
                                pair[1].close();
                            } catch (IllegalStateException e) {
                                // whatever
                            }
                        }
                    });
                }
            }, t -> {
                tracer.outgoingWebsocketException(t);
                t.printStackTrace();
                sres.setStatusCode(HttpResponseStatus.BAD_GATEWAY.code());
                if (t instanceof WebSocketHandshakeRejectedException) {
                    WebSocketHandshakeRejectedException e = (WebSocketHandshakeRejectedException) t;
                    sres.setStatusCode(e.resp.status().code());
                    sres.setStatusMessage(e.resp.status().reasonPhrase());
                    MultiMap cresh = new HeadersAdaptor(e.resp.headers());
                    copyEndToEndHeaders(cresh, sres.headers());
                    sres.headers().add("keep-alive", keepAliveHeaderValue);
                    sres.headers().add("connection", "keep-alive");
                    sres.headers().set("content-length", "0");
                }
                tracer.outgoingResponseInitial();
                tracer.outgoingResponseHeadersEnd(null);
                sres.end();
                tracer.outgoingResponseBodyEnd(null);
            });
            return;
        }
        String expectStr;
        state.expecting100 = null != (expectStr = sreq.headers().get("expect"))
                && expectStr.equalsIgnoreCase("100-continue");
        HttpClientRequest creq = client.request(sreq.method(), nextHop.socketPort, nextHop.socketHost,
                nextHop.uri);
        creq.setTimeout(SECONDS.toMillis(clientReceiveTimeout));
        creq.handler(cres -> {
            cres.exceptionHandler(t -> {
                tracer.incomingResponseException(t);
                if (!state.serverFinished) {
                    state.clientFinished = true;
                    state.serverFinished = true;
                    routingContext.fail(new ProxyException(502, RejectReason.incomingResponseFail, t));
                }
            });
            tracer.incomingResponseStart(cres);
            sres.setStatusCode(cres.statusCode());
            sres.setStatusMessage(cres.statusMessage());
            MultiMap headers = cres.headers();
            copyEndToEndHeaders(headers, sres.headers());
            final boolean reqCompletedBeforeResponse = state.requestComplete;
            if (state.expecting100) {
                log.info("Got " + cres.statusCode() + " instead of 100 Continue");
                if (!isHTTP2) {
                    if (/* state.receivedRequestBodyBefore100 && */ !reqCompletedBeforeResponse) {
                        // TODO investigate whether vertx is able to handle the server request correctly without us closing the conn
                        // but actually the client might have data in transit..
                        log.info(
                                "Client might have started streaming data anyway, so request message boundary is lost. Continue streaming, but close server connection after response complete.");
                        sres.headers().set("connection", "close");
                    } else {
                        log.info(
                                "Client had streamed the complete data anyway. Can carry on without closing server conn.");
                    }
                }
            }
            if (!isHTTP2) {
                if (!sres.headers().contains("connection")
                        || !sres.headers().get("connection").contains("close")) {
                    sres.headers().add("keep-alive", keepAliveHeaderValue);
                    sres.headers().add("connection", "keep-alive");
                }
            }
            if (!headers.contains("content-length")) {
                sres.setChunked(true);
            }
            tracer.outgoingResponseInitial();
            cres.endHandler(v -> {
                tracer.incomingResponseEnd();
                state.clientFinished = true;
                if (!state.serverFinished) {
                    state.serverFinished = true;
                    sres.end();
                }
                if (state.expecting100
                        && /* state.receivedRequestBodyBefore100 && */ !reqCompletedBeforeResponse) {
                    log.info(
                            "Client had started streaming data anyway, so request message boundary is lost. Close client connection.");
                    creq.connection().close();
                }
            });
            pump.start(cres, sres, tracer);
        });
        creq.exceptionHandler(t -> {
            tracer.outgoingRequestException(t);
            if (!state.serverFinished) {
                state.clientFinished = true;
                state.serverFinished = true;
                routingContext.fail(new ProxyException(502, RejectReason.outgoingRequestFail, t));
            }
        });
        MultiMap creqh = creq.headers();
        propagateRequestHeaders(isTls, chost, sreqh, origHost, creqh);
        creq.headers().addAll(addHeaders);
        if (nextHop.hostHeader != null) {
            creq.setHost(nextHop.hostHeader);
        } else {
            creqh.remove("host");
        }
        if (sreqh.getAll("transfer-encoding").stream().anyMatch(v -> v.equals("chunked"))) {
            creq.setChunked(true);
        }
        sres.closeHandler(v -> {
            if (!state.clientFinished) {
                state.clientFinished = true;
                tracer.incomingConnectionPrematurelyClosed();
                HttpConnection connection = creq.connection();
                if (connection != null) {
                    connection.close();
                } // else TODO
            }
            if (!state.serverFinished) {
                state.serverFinished = true;
                routingContext.fail(new ProxyException(0, RejectReason.outgoingResponseFail, null));
            }
        });
        tracer.outgoingRequestInitial(creq);
        if (sreq.isEnded()) {
            state.requestComplete = true;
            Buffer body = routingContext.getBody();
            if (body == null || body.length() == 0) {
                creq.end();
            } else {
                if (!creq.isChunked()) {
                    creq.putHeader("content-length", Integer.toString(body.length()));
                }
                creq.end(routingContext.getBody());
            }
            tracer.incomingRequestEnd();
        } else {
            sreq.endHandler(v -> {
                state.requestComplete = true;
                try {
                    creq.end();
                } catch (IllegalStateException ex) {
                    // ignore - nothing can be done - the request is already complete/closed - TODO log?
                }
                tracer.incomingRequestEnd();
            });

            ReadStream<Buffer> sreqStream;
            if (state.expecting100) {
                log.debug("Expect: 100");
                creq.continueHandler(v -> {
                    // no longer expecting 100, it's like a normal not-expecting-100 request from now on
                    state.expecting100 = false;
                    // since we received 100 Continue, we know the server agrees to accept all the request body, so we can assume we are forgiven for sending data early
                    state.receivedRequestBodyBefore100 = false;
                    log.info("Got 100, propagating");
                    sres.writeContinue();
                });
                // in this case we must flush request headers before the body is sent
                creq.sendHead();
                sreqStream = new ReadStreamWrapper<Buffer>(sreq) {
                    final LazyHandlerWrapper<Buffer> handlerWrapper = new LazyHandlerWrapper<Buffer>(
                            super::handler, null) {
                        @Override
                        public void handle(Buffer event) {
                            log.info("Got first request body chunk");
                            if (state.expecting100) {
                                log.info("Got request body before '100 Continue'");
                                // data received despite not having yet recived 100-continue
                                state.receivedRequestBodyBefore100 = true;
                            }
                            deactivate();
                            wrapped.handle(event);
                        }
                    };

                    @Override
                    public ReadStream<Buffer> handler(Handler<Buffer> handler) {
                        return handlerWrapper.handler(handler, this);
                    }
                };
            } else {
                log.debug("Not expect-100");
                sreqStream = sreq;
            }
            pump.start(sreqStream, creq, tracer);
        }
    });
}

From source file:io.nitor.api.backend.proxy.SimpleLogProxyTracer.java

License:Apache License

String dumpHeaders(MultiMap h, String indent) {
    StringBuilder sb = new StringBuilder();
    for (String name : h.names()) {
        sb.append("\n").append(indent).append(name).append(": ").append(h.getAll(name).stream()
                .reduce((partial, element) -> partial + "\n" + indent + "  " + element).orElse(""));
    }/* w  w  w. ja  va 2 s .  com*/
    return sb.toString();
}

From source file:io.nitor.api.backend.util.Helpers.java

License:Apache License

private static String parseForwarded(MultiMap headers) {
    List<String> values = headers.getAll("forwarded");
    if (values.isEmpty()) {
        return null;
    }/*from w w  w  .  j  ava2  s  .  co m*/
    String forwarded = values.get(values.size() - 1).toLowerCase(ROOT);
    int start = forwarded.lastIndexOf("for=");
    if (start == -1) {
        return null;
    }
    start += 4;
    int end;
    if (forwarded.charAt(start) == '"') {
        start++;
        end = forwarded.indexOf('"', start);
    } else {
        end = forwarded.indexOf(';');
        if (end == -1) {
            end = forwarded.length();
        }
        int end2 = forwarded.indexOf(',');
        if (end2 == -1) {
            end2 = forwarded.length();
        }
        end = min(end, end2);
    }
    forwarded = forwarded.substring(start, end).trim();
    return forwarded;
}

From source file:io.nitor.api.backend.util.Helpers.java

License:Apache License

private static String parseXForwardedHost(MultiMap headers) {
    List<String> values = headers.getAll("x-forwarded-for");
    if (values.isEmpty()) {
        return null;
    }/*from  ww w  .  j av a 2 s .  c o m*/
    String forwardedHost = values.get(values.size() - 1);
    int lastPart = forwardedHost.lastIndexOf(',') + 1;
    forwardedHost = forwardedHost.substring(lastPart).trim();
    return forwardedHost;
}

From source file:io.servicecomb.foundation.vertx.http.VertxServerRequestToHttpServletRequest.java

License:Apache License

@Override
public Map<String, String[]> getParameterMap() {
    Map<String, String[]> paramMap = new HashMap<>();
    MultiMap map = this.vertxRequest.params();
    for (String name : map.names()) {
        List<String> valueList = map.getAll(name);
        paramMap.put(name, (String[]) map.getAll(name).toArray(new String[valueList.size()]));
    }//w  w w  . jav a  2 s.c o m
    return paramMap;
}

From source file:org.apache.servicecomb.foundation.vertx.http.VertxServerRequestToHttpServletRequest.java

License:Apache License

@Override
public Map<String, String[]> getParameterMap() {
    if (parameterMap == null) {
        Map<String, String[]> paramMap = new HashMap<>();
        MultiMap map = this.vertxRequest.params();
        for (String name : map.names()) {
            List<String> valueList = map.getAll(name);
            paramMap.put(name, map.getAll(name).toArray(new String[valueList.size()]));
        }//from  w  w w  . ja  va  2  s . c  o m
        parameterMap = paramMap;
    }

    return parameterMap;
}

From source file:org.hawkular.alerts.handlers.util.ResponseUtil.java

License:Apache License

public static Pager extractPaging(MultiMap params) {
    String pageS = params.get("page") == null ? null : params.get("page");
    String perPageS = params.get("per_page") == null ? null : params.get("per_page");
    List<String> sort = params.getAll("sort");
    List<String> order = params.getAll("order");

    int page = pageS == null ? 0 : Integer.parseInt(pageS);
    int perPage = perPageS == null ? PageContext.UNLIMITED_PAGE_SIZE : Integer.parseInt(perPageS);

    List<Order> ordering = new ArrayList<>();

    if (sort == null || sort.isEmpty()) {
        ordering.add(Order.unspecified());
    } else {// w w  w  .j  a  v  a  2 s  .c  o m
        for (int i = 0; i < sort.size(); ++i) {
            String field = sort.get(i);
            Order.Direction dir = Order.Direction.ASCENDING;
            if (order != null && i < order.size()) {
                dir = Order.Direction.fromShortString(order.get(i));
            }

            ordering.add(Order.by(field, dir));
        }
    }
    return new Pager(page, perPage, ordering);
}

From source file:org.perfcake.message.correlator.GenerateHeaderCorrelator.java

License:Apache License

@Override
public List<String> getResponseCorrelationIds(final Serializable response, final MultiMap headers) {
    return headers.getAll(CORRELATION_HEADER);
}

From source file:org.sfs.metadata.Metadata.java

License:Apache License

public Metadata withHttpHeaders(MultiMap headers) {
    Set<String> processed = new HashSet<>();
    // adds first
    for (String headerName : headers.names()) {
        Matcher matcher = addParser.matcher(headerName);
        if (matcher.find()) {
            List<String> values = headers.getAll(headerName);
            if (values != null && !values.isEmpty()) {
                String metaName = matcher.group(1);
                removeAll(metaName);//from  www  .j  a  v  a2 s  .c  om
                for (String value : values) {
                    for (String split : on(',').omitEmptyStrings().trimResults().split(value)) {
                        processed.add(metaName);
                        put(metaName, split);
                    }
                }
            }
        }
    }
    // then deletes
    for (String headerName : headers.names()) {
        Matcher matcher0 = addParser.matcher(headerName);
        if (matcher0.find()) {
            String metaName = matcher0.group(1);
            if (processed.add(metaName)) {
                List<String> values = headers.getAll(headerName);
                boolean hasData = false;
                if (values != null) {
                    for (String value : values) {
                        if (value != null) {
                            value = value.trim();
                            if (!value.isEmpty()) {
                                hasData = true;
                                break;
                            }
                        }
                    }
                }
                if (!hasData) {
                    removeAll(metaName);
                }
            }
        }
        Matcher matcher1 = removeParser.matcher(headerName);
        if (matcher1.find()) {
            String metaName = matcher1.group(1);
            if (processed.add(metaName)) {
                removeAll(metaName);
            }
        }
    }
    return this;
}