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

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

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.handler.codec.http.*
  5. HttpMethod
  6. GET

Introduction

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

Prototype

HttpMethod GET

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

Click Source Link

Document

The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.

Usage

From source file:com.linkedin.proxy.netty.RocksdbQueryDecoder.java

License:Apache License

@Override
protected void decode(ChannelHandlerContext ctx, FullHttpRequest msg, List<Object> out) throws Exception {
    /*//from   w  w w. j  a va2 s.  com
     * Expected inputs:
     * PUT /dbName/key <value in content>
     * GET /dbName/key
     * DELETE /dbName/key
     */

    Query result = new Query();

    try {
        HttpMethod met = msg.getMethod();
        String uri = msg.getUri();
        int s = 0;
        int e = uri.length();
        if (uri.charAt(0) == '/')
            s = 1;
        if (uri.charAt(e - 1) == '/')
            e--;

        String parts[] = uri.substring(s, e).split("/");

        result.setDbName(parts[0]);
        _LOG.debug("DbName: " + parts[0]);
        result.setKey(parts[1]);
        _LOG.debug("Key: " + parts[1]);

        if (met.equals(HttpMethod.PUT)) {
            /*
             * If HttpRequest method is PUT, I interpret it as a WRITE query.
             * Query instance's value is set as the value in the HttpRequest.
             */
            byte[] tempData = new byte[msg.content().readableBytes()];
            msg.content().readBytes(tempData);
            result.setValue(tempData);
            _LOG.debug("Value size: " + tempData.length);

            result.setType(QueryType.WRITE);
        } else if (met.equals(HttpMethod.GET)) {
            /*
             * If HttpRequest method is GET, I interpret it as a READ query.
             * Once the query is processed, the result value (if any) is written to MysqlQuery.value.
             */
            result.setType(QueryType.READ);
        } else if (met.equals(HttpMethod.DELETE)) {
            /*
             * If HttpRequest method is DELETE, I interpret it as a DELETE query.
             */
            result.setType(QueryType.DELETE);
        } else {
            result.setType(QueryType.INVALID);
            _LOG.error("Unhandled HttpMethod: " + met);
            _LOG.error("Type=" + QueryType.INVALID);
        }

        _LOG.debug("Type: " + result.getType());
    } catch (Exception e) {
        _LOG.error("Exception occured during HttpRequest processing", e);
        result.setType(QueryType.INVALID);
        _LOG.error("Type=" + QueryType.INVALID);
    }

    out.add(result);
}

From source file:com.litgh.RouterTest.java

License:Open Source License

public void testRouter() {
    Router router = new Router();
    final Map<String, Boolean> test = new HashMap<String, Boolean>();
    router.GET("/user/:name", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("routed", true);
            Param want = new Param("name", "router");
            if (params.size() == 1 && want.getKey().equals(params.get(0).getKey())
                    && want.getValue().equals(params.get(0).getValue())) {
                test.put("paramed1", true);
            } else {
                test.put("paramed1", false);
            }/*from   w  w w. j  av  a2  s  .  c  o  m*/

        }
    });

    HttpRequest req = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/user/router");
    FullHttpResponse resp = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
    router.serverHttp(req, resp);

    assertEquals("routed", Boolean.TRUE, test.get("routed"));
    assertEquals("paramed1", Boolean.TRUE, test.get("paramed1"));
}

From source file:com.litgh.RouterTest.java

License:Open Source License

public void testRouter1() {
    Router router = new Router();
    final Map<String, Boolean> test = new HashMap<String, Boolean>();
    router.GET("/user/:firstname/:lastname", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("routed", true);
            Param want1 = new Param("firstname", "fname");
            Param want2 = new Param("lastname", "lname");

            if (params.size() == 2 && want1.getKey().equals(params.get(0).getKey())
                    && want1.getValue().equals(params.get(0).getValue())
                    && want2.getKey().equals(params.get(1).getKey())
                    && want2.getValue().equals(params.get(1).getValue())) {
                test.put("paramed2", true);
            } else {
                test.put("paramed2", false);
            }/*from www .j a v  a2 s  . c  o m*/

        }
    });

    HttpRequest req = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/user/fname/lname");
    FullHttpResponse resp = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
    router.serverHttp(req, resp);

    assertEquals("routed", Boolean.TRUE, test.get("routed"));
    assertEquals("paramed2", Boolean.TRUE, test.get("paramed"));
}

From source file:com.litgh.RouterTest.java

License:Open Source License

public void testRouterAPI() {
    Router router = new Router();
    final Map<String, Boolean> test = new HashMap<String, Boolean>();

    router.GET("/GET", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("GET", true);
        }/*from   www  .jav  a2 s .c o m*/
    });

    router.POST("/POST", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("POST", true);
        }
    });

    router.PUT("/PUT", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("PUT", true);
        }
    });

    router.DELETE("/DELETE", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("DELETE", true);
        }
    });

    router.HEAD("/HEAD", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("HEAD", true);
        }
    });

    router.PATCH("/PATCH", new Handler() {
        public void handle(HttpRequest req, FullHttpResponse resp, List<Param> params) {
            test.put("PATCH", true);
        }
    });

    HttpRequest req = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/GET");
    FullHttpResponse resp = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
    router.serverHttp(req, resp);

    req.setMethod(HttpMethod.POST);
    req.setUri("/POST");
    router.serverHttp(req, resp);

    req.setMethod(HttpMethod.PUT);
    req.setUri("/PUT");
    router.serverHttp(req, resp);

    req.setMethod(HttpMethod.DELETE);
    req.setUri("/DELETE");
    router.serverHttp(req, resp);

    req.setMethod(HttpMethod.HEAD);
    req.setUri("/HEAD");
    router.serverHttp(req, resp);

    req.setMethod(HttpMethod.PATCH);
    req.setUri("/PATCH");
    router.serverHttp(req, resp);

    assertEquals("routing GET failed", Boolean.TRUE, test.get("GET"));
    assertEquals("routing POST failed", Boolean.TRUE, test.get("POST"));
    assertEquals("routing PUT failed", Boolean.TRUE, test.get("PUT"));
    assertEquals("routing DELETE failed", Boolean.TRUE, test.get("DELETE"));
    assertEquals("routing HEAD failed", Boolean.TRUE, test.get("HEAD"));
    assertEquals("routing PATCH failed", Boolean.TRUE, test.get("PATCH"));
}

From source file:com.look.netty.demo.upload.HttpUploadServerHandler.java

License:Apache License

@Override
public void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
    if (msg instanceof HttpRequest) {
        HttpRequest request = this.request = (HttpRequest) msg;
        URI uri = new URI(request.uri());
        if (!uri.getPath().startsWith("/form")) {
            // Write Menu
            writeMenu(ctx);// w  w  w  . jav  a 2  s.c o  m
            return;
        }
        responseContent.setLength(0);
        responseContent.append("WELCOME TO THE WILD WILD WEB SERVER\r\n");
        responseContent.append("===================================\r\n");

        responseContent.append("VERSION: " + request.protocolVersion().text() + "\r\n");

        responseContent.append("REQUEST_URI: " + request.uri() + "\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(HttpHeaderNames.COOKIE);
        if (value == null) {
            cookies = Collections.emptySet();
        } else {
            cookies = ServerCookieDecoder.STRICT.decode(value);
        }
        for (Cookie cookie : cookies) {
            responseContent.append("COOKIE: " + cookie + "\r\n");
        }
        responseContent.append("\r\n\r\n");

        QueryStringDecoder decoderQuery = new QueryStringDecoder(request.uri());
        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.method().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");
            // Not now: LastHttpContent will be sent 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 = HttpUtil.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();
            System.err.println(new String(responseContent.toString().getBytes(), "UTF-8"));
            // example of reading only if at the end
            if (chunk instanceof LastHttpContent) {
                writeResponse(ctx.channel());
                readingChunks = false;

                reset();
            }
        }
    } else {
        writeResponse(ctx.channel());
    }
}

From source file:com.mastfrog.netty.http.client.CookieStoreTest.java

License:Open Source License

@Test
public void test() throws IOException {
    assertTrue(true);//from  w w  w .ja  v  a 2 s .  c  o m
    CookieStore store = new CookieStore();
    DefaultCookie ck1 = new DefaultCookie("foo", "bar");
    DefaultCookie ck2 = new DefaultCookie("one", "two");
    ck1.setPath("/foo");
    ck1.setDomain("foo.com");
    ck1.setMaxAge(10000);

    ck2.setPath("/foo");
    ck2.setDomain("foo.com");
    ck2.setMaxAge(10000);

    DefaultFullHttpResponse resp = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
    resp.headers().add(Headers.SET_COOKIE.name(), Headers.SET_COOKIE.toString(ck1));
    resp.headers().add(Headers.SET_COOKIE.name(), Headers.SET_COOKIE.toString(ck2));

    store.extract(resp.headers());
    Iterator<Cookie> iter = store.iterator();
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());

    HttpRequest req = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/foo/bar");
    req.headers().add(Headers.HOST.name(), "foo.com");
    store.decorate(req);

    List<String> cookieHeaders = req.headers().getAll(Headers.COOKIE.name());
    assertEquals(2, cookieHeaders.size());

    List<String> find = new LinkedList<>(Arrays.asList("foo", "one"));
    for (String hdr : cookieHeaders) {
        Cookie cookie = Headers.SET_COOKIE.toValue(hdr);
        find.remove(cookie.getName());
    }
    assertTrue("Not found: " + find, find.isEmpty());

    CookieStore nue = new CookieStore(store.cookies, true, true);
    assertEquals(store, nue);

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    store.store(out);
    ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
    nue = new CookieStore();
    nue.read(in);
    assertEquals(store, nue);

    DefaultCookie ck3 = new DefaultCookie("fuz", "bang");
    ck3.setMaxAge(20000);
    ck3.setPath("/moo/wuzz");
    ck3.setDomain("foo.com");
    nue.add(ck3);
    assertNotEquals(store, nue);
}

From source file:com.mattrjacobs.hystrix.client.rxnetty.ExampleClient.java

License:Apache License

public Observable<String> makeCall() {
    HttpClientRequest<ByteBuf> req = HttpClientRequest.create(HttpVersion.HTTP_1_1, HttpMethod.GET, "/example");
    return httpClient.submit(req).flatMap(HttpClientResponse<ByteBuf>::getContent)
            .map(bb -> bb.toString(Charset.defaultCharset()));
}

From source file:com.navercorp.pinpoint.plugin.netty.NettyIT.java

License:Apache License

@Test
public void listenerTest() throws Exception {
    final CountDownLatch awaitLatch = new CountDownLatch(1);

    Bootstrap bootstrap = client();//from  ww  w  .  ja  v a  2  s  .  c o  m
    Channel channel = bootstrap.connect(webServer.getHostname(), webServer.getListeningPort()).sync().channel();

    channel.pipeline().addLast(new SimpleChannelInboundHandler<FullHttpResponse>() {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, FullHttpResponse msg) throws Exception {
            awaitLatch.countDown();
        }
    });

    HttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
    channel.writeAndFlush(request);

    boolean await = awaitLatch.await(3000, TimeUnit.MILLISECONDS);
    Assert.assertTrue(await);

    PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance();
    verifier.printCache();

    verifier.verifyTrace(event("NETTY", Bootstrap.class.getMethod("connect", SocketAddress.class),
            annotation("netty.address", webServer.getHostAndPort())));
    verifier.verifyTrace(
            event("NETTY", "io.netty.channel.DefaultChannelPipeline.writeAndFlush(java.lang.Object)"));
    verifier.verifyTrace(event("ASYNC", "Asynchronous Invocation"));
    verifier.verifyTrace(event("NETTY_HTTP",
            "io.netty.handler.codec.http.HttpObjectEncoder.encode(io.netty.channel.ChannelHandlerContext, java.lang.Object, java.util.List)",
            annotation("http.url", "/")));
}

From source file:com.navercorp.pinpoint.plugin.netty.NettyIT.java

License:Apache License

@Test
public void writeTest() throws Exception {
    final CountDownLatch awaitLatch = new CountDownLatch(1);

    Bootstrap bootstrap = client();//from  w  w  w  . jav  a 2s .c o m
    bootstrap.connect(webServer.getHostname(), webServer.getListeningPort())
            .addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (future.isSuccess()) {
                        Channel channel = future.channel();
                        channel.pipeline().addLast(new SimpleChannelInboundHandler() {

                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, Object msg)
                                    throws Exception {
                                awaitLatch.countDown();
                            }

                        });
                        HttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,
                                "/");
                        future.channel().writeAndFlush(request);
                    }
                }

            });

    boolean await = awaitLatch.await(3000, TimeUnit.MILLISECONDS);
    Assert.assertTrue(await);

    PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance();
    verifier.printCache();

    verifier.verifyTrace(event("NETTY", Bootstrap.class.getMethod("connect", SocketAddress.class),
            annotation("netty.address", webServer.getHostAndPort())));
    verifier.verifyTrace(event("NETTY",
            "io.netty.channel.DefaultChannelPromise.addListener(io.netty.util.concurrent.GenericFutureListener)"));
    verifier.verifyTrace(event("ASYNC", "Asynchronous Invocation"));
    verifier.verifyTrace(
            event("NETTY_INTERNAL", "io.netty.util.concurrent.DefaultPromise.notifyListenersNow()"));
    verifier.verifyTrace(event("NETTY_INTERNAL",
            "io.netty.util.concurrent.DefaultPromise.notifyListener0(io.netty.util.concurrent.Future, io.netty.util.concurrent.GenericFutureListener)"));
    verifier.verifyTrace(
            event("NETTY", "io.netty.channel.DefaultChannelPipeline.writeAndFlush(java.lang.Object)"));
    verifier.verifyTrace(event("NETTY_HTTP",
            "io.netty.handler.codec.http.HttpObjectEncoder.encode(io.netty.channel.ChannelHandlerContext, java.lang.Object, java.util.List)",
            annotation("http.url", "/")));
}

From source file:com.netflix.client.netty.http.NettyHttpClient.java

License:Apache License

private RequestSpecificRetryHandler getRequestRetryHandler(HttpClientRequest<?> request,
        IClientConfig requestConfig) {/*from w w  w  .  ja  v  a2  s .  com*/
    boolean okToRetryOnAllErrors = request.getMethod().equals(HttpMethod.GET);
    return new RequestSpecificRetryHandler(true, okToRetryOnAllErrors, lbExecutor.getRetryHandler(),
            requestConfig);
}