Example usage for io.netty.handler.codec.http HttpMethod POST

List of usage examples for io.netty.handler.codec.http HttpMethod POST

Introduction

In this page you can find the example usage for io.netty.handler.codec.http HttpMethod POST.

Prototype

HttpMethod POST

To view the source code for io.netty.handler.codec.http HttpMethod POST.

Click Source Link

Document

The POST method is used to request that the origin server accept the entity enclosed in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line.

Usage

From source file:io.urmia.job.codec.JobDecoder.java

License:Open Source License

JobRequest decode(FullHttpRequest fullHttpRequest) {

    final String uri = fullHttpRequest.getUri();
    final HttpMethod method = fullHttpRequest.getMethod();

    if (HttpMethod.GET.equals(method)) {
        if (isGet(uri))
            return new JobGetRequest(fullHttpRequest);

        return new JobQueryRequest(fullHttpRequest);
    }//from  w  w  w . j  a v a  2  s.c  om

    if (HttpMethod.POST.equals(method)) {
        if (isInput(uri))
            return new JobInputRequest(fullHttpRequest);

        if (isCancel(uri))
            return new JobCancelRequest(fullHttpRequest);

        return new JobCreateRequest(fullHttpRequest);
    }

    throw new IllegalArgumentException("unknown job request: " + method + " " + uri);
}

From source file:io.vertx.core.http.impl.HttpServerRequestImpl.java

License:Open Source License

@Override
public HttpServerRequest setExpectMultipart(boolean expect) {
    synchronized (conn) {
        checkEnded();/*from w  w  w  .  j a  v  a2 s.c  o m*/
        if (expect) {
            if (decoder == null) {
                String contentType = request.headers().get(HttpHeaders.Names.CONTENT_TYPE);
                if (contentType != null) {
                    HttpMethod method = request.getMethod();
                    String lowerCaseContentType = contentType.toLowerCase();
                    boolean isURLEncoded = lowerCaseContentType
                            .startsWith(HttpHeaders.Values.APPLICATION_X_WWW_FORM_URLENCODED);
                    if ((lowerCaseContentType.startsWith(HttpHeaders.Values.MULTIPART_FORM_DATA)
                            || isURLEncoded)
                            && (method.equals(HttpMethod.POST) || method.equals(HttpMethod.PUT)
                                    || method.equals(HttpMethod.PATCH) || method.equals(HttpMethod.DELETE))) {
                        decoder = new HttpPostRequestDecoder(
                                new NettyFileUploadDataFactory(conn.vertx(), this, () -> uploadHandler),
                                request);
                    }
                }
            }
        } else {
            decoder = null;
        }
        return this;
    }
}

From source file:io.vertx.core.http.impl.HttpUtils.java

License:Open Source License

static HttpMethod toNettyHttpMethod(io.vertx.core.http.HttpMethod method, String rawMethod) {
    switch (method) {
    case CONNECT: {
        return HttpMethod.CONNECT;
    }/*from  w w w .  j  a v a2 s.com*/
    case GET: {
        return HttpMethod.GET;
    }
    case PUT: {
        return HttpMethod.PUT;
    }
    case POST: {
        return HttpMethod.POST;
    }
    case DELETE: {
        return HttpMethod.DELETE;
    }
    case HEAD: {
        return HttpMethod.HEAD;
    }
    case OPTIONS: {
        return HttpMethod.OPTIONS;
    }
    case TRACE: {
        return HttpMethod.TRACE;
    }
    case PATCH: {
        return HttpMethod.PATCH;
    }
    default: {
        return HttpMethod.valueOf(rawMethod);
    }
    }
}

From source file:me.zhuoran.amoeba.netty.server.HttpServerHandler.java

License:Apache License

protected void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
    AmoebaHttpRequest request = null;// w  w w  .ja va2  s. c om
    if (msg instanceof HttpRequest) {
        HttpRequest httpContent = (HttpRequest) msg;
        if (!httpContent.getDecoderResult().isSuccess()) {
            sendHttpResponse(ctx, httpContent,
                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }

        if (httpContent.getMethod() != HttpMethod.GET && httpContent.getMethod() != HttpMethod.POST) {
            sendHttpResponse(ctx, httpContent,
                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.FORBIDDEN));
            return;
        }

        if (HttpHeaders.is100ContinueExpected(httpContent)) {
            ctx.write(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE));
        }

        String uri = HttpRequestHandler.sanitizeUri(httpContent.getUri());
        if (!HttpServer.executorNameList.contains(uri)) {
            DefaultFullHttpResponse response1 = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
                    HttpResponseStatus.NOT_FOUND);
            sendHttpResponse(ctx, httpContent, response1);
            return;
        }

        request = new AmoebaHttpRequest(httpContent, ctx.channel().id().asLongText());
    }

    if (msg instanceof HttpContent) {
        HttpContent httpContent = (HttpContent) msg;
        ByteBuf content = httpContent.content();
        request.setHttpContent(content);
        request.setContent(content.toString(CharsetUtil.UTF_8));
        if (msg instanceof LastHttpContent) {
            FullHttpResponse response = this.getHttpResponse(request);
            this.writeResponse(request, response, ctx);
        }
    }

}

From source file:net.anyflow.menton.http.HttpClient.java

License:Apache License

@Override
public HttpResponse post(final MessageReceiver receiver) {
    httpRequest().setMethod(HttpMethod.POST);

    return request(receiver);
}

From source file:net.anyflow.menton.http.HttpRequest.java

License:Apache License

public Map<String, List<String>> parameters() {

    if (parameters != null) {
        return parameters;
    }//from  w  w w  .  j  a v a2  s  .  co  m

    Map<String, List<String>> ret = Maps.newHashMap();

    if (HttpMethod.GET.equals(method()) || HttpMethod.DELETE.equals(method())) {
        ret.putAll((new QueryStringDecoder(uri())).parameters());
        return ret;
    } else if (headers().contains(HttpHeaderNames.CONTENT_TYPE)
            && headers().get(HttpHeaderNames.CONTENT_TYPE)
                    .startsWith(HttpHeaderValues.APPLICATION_X_WWW_FORM_URLENCODED.toString())
            && (HttpMethod.POST.equals(method()) || HttpMethod.PUT.equals(method()))) {

        ret.putAll((new QueryStringDecoder("/dummy?" + content().toString(CharsetUtil.UTF_8))).parameters());
    }

    return ret;
}

From source file:net.anyflow.menton.http.HttpRequest.java

License:Apache License

private void normalizeParameters() {
    String address = (new StringBuilder()).append(uriObject().getScheme()).append("://")
            .append(uriObject().getAuthority()).append(uriObject().getPath()).toString();

    if (HttpMethod.GET.equals(method()) || HttpMethod.DELETE.equals(method())) {
        String parameters = convertParametersToString();
        address += Strings.isNullOrEmpty(parameters) ? "" : "?" + parameters;
    } else if ((HttpMethod.POST.equals(method()) || HttpMethod.PUT.equals(method()))
            && (headers().contains(HttpHeaderNames.CONTENT_TYPE) == false
                    || headers().get(HttpHeaderNames.CONTENT_TYPE)
                            .startsWith(HttpHeaderValues.APPLICATION_X_WWW_FORM_URLENCODED.toString()))) {
        ByteBuf content = Unpooled.copiedBuffer(convertParametersToString(), CharsetUtil.UTF_8);

        headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
        content().clear();/* www . ja  v a 2  s  . com*/
        content().writeBytes(content);
    }

    setUri(address);
}

From source file:net.hasor.rsf.center.server.launcher.http.HttpClient.java

License:Apache License

public BasicFuture<HttpResponse> request(String requestPath, Map<String, String> reqParams, byte[] body)
        throws Exception {
    // ?Netty/*from  www .  j  ava  2s.  com*/
    final Bootstrap b = new Bootstrap();
    final BasicFuture<HttpResponse> future = new BasicFuture<HttpResponse>();
    b.group(this.worker);
    b.channel(NioSocketChannel.class);
    b.option(ChannelOption.SO_KEEPALIVE, true);
    b.handler(new ChannelInitializer<SocketChannel>() {
        public void initChannel(SocketChannel ch) throws Exception {
            // httpResponse??HttpResponseDecoder?
            ch.pipeline().addLast(new HttpResponseDecoder());
            // ??httprequest?HttpRequestEncoder?
            ch.pipeline().addLast(new HttpRequestEncoder());
            ch.pipeline().addLast(new ResponseRead(future));
        }
    });
    //
    // Server
    ChannelFuture f = b.connect(this.remoteHost, this.remotePort).sync();
    //
    // http
    URL reqPath = new URL("http", this.remoteHost, this.remotePort, requestPath);
    DefaultFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST,
            reqPath.toString());
    request.headers().set(HttpHeaders.Names.HOST, this.remoteHost);
    request.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
    request.headers().set(HttpHeaders.Names.CONTENT_LENGTH, request.content().readableBytes());
    //
    // ??http
    if (body != null) {
        request.content().writeBytes(body);
    }
    f.channel().write(request);
    f.channel().flush();
    //
    // 
    f.channel().closeFuture().addListener(new ChannelFutureListener() {
        public void operationComplete(ChannelFuture nettyFuture) throws Exception {
            future.cancel();//?
        }
    });
    return future;
}

From source file:net.mms_projects.copy_it.api.http.Handler.java

License:Open Source License

/**
 * Internal message handler, this is where all the http requests come in. This is where most of the authorization
 * and page logic goes on.//  w ww. java  2s  .c  o  m
 * @see net.mms_projects.copy_it.api.http.Page
 * @see net.mms_projects.copy_it.api.oauth.HeaderVerifier
 */
protected void messageReceived(final ChannelHandlerContext chx, final HttpObject o) throws Exception {
    if (o instanceof HttpRequest) {
        final HttpRequest http = (HttpRequest) o;
        this.request = http;
        final URI uri = new URI(request.getUri());
        if ((page = Page.getNoAuthPage(uri.getPath())) != null) {
            database = DatabasePool.getDBConnection();
            if (request.getMethod() == HttpMethod.GET) {
                try {
                    final FullHttpResponse response = page.onGetRequest(request, database);
                    HttpHeaders.setContentLength(response, response.content().readableBytes());
                    HttpHeaders.setHeader(response, CONTENT_TYPE, page.GetContentType());
                    if (isKeepAlive(request)) {
                        HttpHeaders.setKeepAlive(response, true);
                        chx.write(response);
                    } else
                        chx.write(response).addListener(ChannelFutureListener.CLOSE);
                } catch (ErrorException e) {
                    e.printStackTrace();
                    final FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(),
                            e.getStatus(), Unpooled.copiedBuffer(e.toString(), CharsetUtil.UTF_8));
                    HttpHeaders.setHeader(response, CONTENT_TYPE, Page.ContentTypes.JSON_TYPE);
                    chx.write(response).addListener(ChannelFutureListener.CLOSE);
                } catch (Exception e) {
                    e.printStackTrace();
                    final FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(),
                            INTERNAL_SERVER_ERROR);
                    chx.write(response).addListener(ChannelFutureListener.CLOSE);
                }
            } else if (request.getMethod() == HttpMethod.POST)
                postRequestDecoder = new HttpPostRequestDecoder(request);
        } else if ((page = Page.getAuthPage(uri.getPath())) == null) {
            final FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(),
                    NOT_FOUND, Unpooled.copiedBuffer("404", CharsetUtil.UTF_8));
            chx.write(response).addListener(ChannelFutureListener.CLOSE);
        } else {
            try {
                headerVerifier = new HeaderVerifier(http, uri);
                database = DatabasePool.getDBConnection();
                headerVerifier.verifyConsumer(database);
                headerVerifier.verifyOAuthToken(database);
                headerVerifier.verifyOAuthNonce(database);
                if (request.getMethod() == HttpMethod.GET) {
                    headerVerifier.checkSignature(null, false);
                    final FullHttpResponse response = ((AuthPage) page).onGetRequest(request, database,
                            headerVerifier);
                    HttpHeaders.setContentLength(response, response.content().readableBytes());
                    HttpHeaders.setHeader(response, CONTENT_TYPE, page.GetContentType());
                    if (isKeepAlive(request)) {
                        HttpHeaders.setKeepAlive(response, true);
                        chx.write(response);
                    } else
                        chx.write(response).addListener(ChannelFutureListener.CLOSE);
                } else if (request.getMethod() == HttpMethod.POST)
                    postRequestDecoder = new HttpPostRequestDecoder(request);
            } catch (ErrorException e) {
                e.printStackTrace();
                final FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(),
                        e.getStatus(), Unpooled.copiedBuffer(e.toString(), CharsetUtil.UTF_8));
                HttpHeaders.setHeader(response, CONTENT_TYPE, Page.ContentTypes.JSON_TYPE);
                chx.write(response).addListener(ChannelFutureListener.CLOSE);
            } catch (Exception e) {
                e.printStackTrace();
                final FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(),
                        INTERNAL_SERVER_ERROR);
                chx.write(response).addListener(ChannelFutureListener.CLOSE);
            }
        }
    } else if (o instanceof HttpContent && request != null && request.getMethod() == HttpMethod.POST) {
        final HttpContent httpContent = (HttpContent) o;
        postRequestDecoder.offer(httpContent);
        if (o instanceof LastHttpContent && page != null) {
            try {
                FullHttpResponse response;
                if (headerVerifier != null && page instanceof AuthPage) {
                    headerVerifier.checkSignature(postRequestDecoder, false);
                    response = ((AuthPage) page).onPostRequest(request, postRequestDecoder, database,
                            headerVerifier);
                } else
                    response = page.onPostRequest(request, postRequestDecoder, database);
                HttpHeaders.setContentLength(response, response.content().readableBytes());
                HttpHeaders.setHeader(response, CONTENT_TYPE, page.GetContentType());
                if (isKeepAlive(request)) {
                    HttpHeaders.setKeepAlive(response, true);
                    chx.write(response);
                } else
                    chx.write(response).addListener(ChannelFutureListener.CLOSE);
            } catch (ErrorException e) {
                e.printStackTrace();
                final FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(),
                        e.getStatus(), Unpooled.copiedBuffer(e.toString(), CharsetUtil.UTF_8));
                HttpHeaders.setHeader(response, CONTENT_TYPE, Page.ContentTypes.JSON_TYPE);
                chx.write(response).addListener(ChannelFutureListener.CLOSE);
            } catch (Exception e) {
                e.printStackTrace();
                final FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(),
                        INTERNAL_SERVER_ERROR);
                chx.write(response).addListener(ChannelFutureListener.CLOSE);
            }
        }
    }
    if (o instanceof LastHttpContent && database != null)
        database.free();
}

From source file:net.mms_projects.copy_it.api.oauth.HeaderVerifier.java

License:Open Source License

/**
 * Create method for the raw signature base for post requests
 * @see net.mms_projects.copy_it.api.oauth.HeaderVerifier#checkSignature(io.netty.handler.codec.http.multipart.HttpPostRequestDecoder, boolean)
 */// w ww.j av a  2s . com
private String createRaw(HttpPostRequestDecoder post, boolean https)
        throws UnsupportedEncodingException, URISyntaxException {
    final StringBuilder rawbuilder = new StringBuilder();
    rawbuilder.append(request.getMethod().toString());
    rawbuilder.append('&');
    rawbuilder.append(HTTP);
    if (https)
        rawbuilder.append('s');
    rawbuilder.append(COLON_SLASH_SLASH);
    rawbuilder.append(URLEncoder.encode(request.headers().get(HOST), UTF_8));
    rawbuilder.append(URLEncoder.encode(uri.getPath(), UTF_8));
    rawbuilder.append('&');
    if (uri.getQuery() == null && request.getMethod() == HttpMethod.GET) {
        String[] loop_through = OAuthParameters.KEYS;
        if ((flags & Flags.REQUIRES_VERIFIER) == Flags.REQUIRES_VERIFIER)
            loop_through = OAuthParameters.VERIFIER_KEYS;
        for (int i = 0; i < loop_through.length; i++) {
            rawbuilder.append(loop_through[i]);
            rawbuilder.append(EQUALS);
            rawbuilder.append(URLEncoder.encode(oauth_params.get(loop_through[i]), UTF_8));
            if (i != (loop_through.length - 1))
                rawbuilder.append(AND);
        }
    } else {
        final List<String> keys = new ArrayList<String>();
        final Map<String, String> parameters = new HashMap<String, String>();
        if (request.getMethod() == HttpMethod.GET) {
            final QueryStringDecoder querydecoder = new QueryStringDecoder(uri);
            final Map<String, List<String>> get_parameters = querydecoder.parameters();
            final Set<String> keyset = parameters.keySet();
            final Iterator<String> iter = keyset.iterator();
            while (iter.hasNext()) {
                final String key = iter.next();
                keys.add(key);
                parameters.put(key, get_parameters.get(key).get(0));
            }
        } else if (request.getMethod() == HttpMethod.POST) {
            final List<InterfaceHttpData> post_parameters = post.getBodyHttpDatas();
            final Iterator<InterfaceHttpData> iter = post_parameters.iterator();
            while (iter.hasNext()) {
                final InterfaceHttpData data = iter.next();
                try {
                    final HttpData httpData = (HttpData) data;
                    parameters.put(httpData.getName(),
                            URLEncoder.encode(httpData.getString(), UTF_8).replace(PLUS, PLUS_ENCODED));
                    keys.add(httpData.getName());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        for (int i = 0; i < OAuthParameters.KEYS.length; i++)
            keys.add(OAuthParameters.KEYS[i]);
        if ((flags & Flags.REQUIRES_VERIFIER) == Flags.REQUIRES_VERIFIER)
            keys.add(OAuthParameters.OAUTH_VERIFIER);
        Collections.sort(keys);
        final int length = keys.size();
        for (int i = 0; i < length; i++) {
            final String key = keys.get(i);
            rawbuilder.append(key);
            rawbuilder.append(EQUALS);
            if (key.startsWith(OAUTH_))
                rawbuilder.append(URLEncoder.encode(oauth_params.get(key), UTF_8));
            else
                rawbuilder.append(URLEncoder.encode(parameters.get(key), UTF_8));
            if (i != (length - 1))
                rawbuilder.append(AND);
        }
    }
    System.err.println(rawbuilder.toString());
    return rawbuilder.toString();
}