cloud/stack/src/main/java/org/iotivity/cloud/base/HttpClient.java

   1 /*
   2  *******************************************************************
   3  *
   4  * Copyright 2016 Samsung Electronics All Rights Reserved.
   5  *
   6  *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21  */
  22 // package org.iotivity.cloud.base;
  23 //
  24 // import java.net.URI;
  25 // import java.net.URISyntaxException;
  26 //
  27 // import javax.net.ssl.SSLException;
  28 //
  29 // import io.netty.bootstrap.Bootstrap;
  30 // import io.netty.channel.Channel;
  31 // import io.netty.channel.ChannelHandlerContext;
  32 // import io.netty.channel.ChannelInitializer;
  33 // import io.netty.channel.ChannelPipeline;
  34 // import io.netty.channel.EventLoopGroup;
  35 // import io.netty.channel.SimpleChannelInboundHandler;
  36 // import io.netty.channel.nio.NioEventLoopGroup;
  37 // import io.netty.channel.socket.SocketChannel;
  38 // import io.netty.channel.socket.nio.NioSocketChannel;
  39 // import io.netty.handler.codec.http.ClientCookieEncoder;
  40 // import io.netty.handler.codec.http.DefaultCookie;
  41 // import io.netty.handler.codec.http.DefaultFullHttpRequest;
  42 // import io.netty.handler.codec.http.HttpClientCodec;
  43 // import io.netty.handler.codec.http.HttpContent;
  44 // import io.netty.handler.codec.http.HttpContentDecompressor;
  45 // import io.netty.handler.codec.http.HttpHeaders;
  46 // import io.netty.handler.codec.http.HttpMethod;
  47 // import io.netty.handler.codec.http.HttpObject;
  48 // import io.netty.handler.codec.http.HttpRequest;
  49 // import io.netty.handler.codec.http.HttpResponse;
  50 // import io.netty.handler.codec.http.HttpVersion;
  51 // import io.netty.handler.codec.http.LastHttpContent;
  52 // import io.netty.handler.ssl.SslContext;
  53 // import io.netty.handler.ssl.SslContextBuilder;
  54 // import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
  55 // import io.netty.util.CharsetUtil;
  56 //
  57 // public class HttpClient {
  58 //
  59 // private static class HttpClientInitializer
  60 // extends ChannelInitializer<SocketChannel> {
  61 //
  62 // public static class HttpSnoopClientHandler
  63 // extends SimpleChannelInboundHandler<HttpObject> {
  64 //
  65 // @Override
  66 // public void channelRead0(ChannelHandlerContext ctx,
  67 // HttpObject msg) {
  68 // if (msg instanceof HttpResponse) {
  69 // HttpResponse response = (HttpResponse) msg;
  70 //
  71 // System.err.println("STATUS: " + response.getStatus());
  72 // System.err.println(
  73 // "VERSION: " + response.getProtocolVersion());
  74 // System.err.println();
  75 //
  76 // if (!response.headers().isEmpty()) {
  77 // for (String name : response.headers().names()) {
  78 // for (String value : response.headers()
  79 // .getAll(name)) {
  80 // System.err.println(
  81 // "HEADER: " + name + " = " + value);
  82 // }
  83 // }
  84 // System.err.println();
  85 // }
  86 //
  87 // if (HttpHeaders.isTransferEncodingChunked(response)) {
  88 // System.err.println("CHUNKED CONTENT {");
  89 // } else {
  90 // System.err.println("CONTENT {");
  91 // }
  92 // }
  93 // if (msg instanceof HttpContent) {
  94 // HttpContent content = (HttpContent) msg;
  95 //
  96 // System.err.print(
  97 // content.content().toString(CharsetUtil.UTF_8));
  98 // System.err.flush();
  99 //
 100 // if (content instanceof LastHttpContent) {
 101 // System.err.println("} END OF CONTENT");
 102 // ctx.close();
 103 // }
 104 // }
 105 // }
 106 //
 107 // @Override
 108 // public void exceptionCaught(ChannelHandlerContext ctx,
 109 // Throwable cause) {
 110 // cause.printStackTrace();
 111 // ctx.close();
 112 // }
 113 // }
 114 //
 115 // private final SslContext sslCtx;
 116 //
 117 // public HttpClientInitializer(SslContext sslCtx) {
 118 // this.sslCtx = sslCtx;
 119 // }
 120 //
 121 // @Override
 122 // public void initChannel(SocketChannel ch) {
 123 // ChannelPipeline p = ch.pipeline();
 124 //
 125 // // Enable HTTPS if necessary.
 126 // if (sslCtx != null) {
 127 // p.addLast(sslCtx.newHandler(ch.alloc()));
 128 // }
 129 //
 130 // p.addLast(new HttpClientCodec());
 131 //
 132 // // Remove the following line if you don't want automatic content
 133 // // decompression.
 134 // p.addLast(new HttpContentDecompressor());
 135 //
 136 // // Uncomment the following line if you don't want to handle
 137 // // HttpContents.
 138 // // p.addLast(new HttpObjectAggregator(1048576));
 139 //
 140 // p.addLast(new HttpSnoopClientHandler());
 141 // }
 142 // }
 143 //
 144 // public void connect(String strUrl)
 145 // throws URISyntaxException, InterruptedException, SSLException {
 146 // URI uri = new URI(strUrl);
 147 //
 148 // String scheme = uri.getScheme() == null ? "http" : uri.getScheme();
 149 // String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost();
 150 //
 151 // int port = uri.getPort();
 152 //
 153 // if (port == -1) {
 154 // if ("http".equalsIgnoreCase(scheme)) {
 155 // port = 80;
 156 // } else if ("https".equalsIgnoreCase(scheme)) {
 157 // port = 443;
 158 // }
 159 // }
 160 //
 161 // if (!"http".equalsIgnoreCase(scheme)
 162 // && !"https".equalsIgnoreCase(scheme)) {
 163 // return;
 164 // }
 165 //
 166 // final boolean ssl = "https".equalsIgnoreCase(scheme);
 167 // final SslContext sslCtx;
 168 //
 169 // if (ssl) {
 170 // sslCtx = SslContextBuilder.forClient()
 171 // .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
 172 // } else {
 173 // sslCtx = null;
 174 // }
 175 //
 176 // EventLoopGroup group = new NioEventLoopGroup();
 177 //
 178 // try {
 179 // Bootstrap b = new Bootstrap();
 180 // b.group(group);
 181 // b.channel(NioSocketChannel.class);
 182 // b.handler(new HttpClientInitializer(sslCtx));
 183 //
 184 // Channel ch = b.connect(host, port).sync().channel();
 185 //
 186 // HttpRequest request = new DefaultFullHttpRequest(
 187 // HttpVersion.HTTP_1_1, HttpMethod.GET, uri.getRawPath());
 188 // request.headers().set(HttpHeaders.Names.HOST, host);
 189 // request.headers().set(HttpHeaders.Names.CONNECTION,
 190 // HttpHeaders.Values.CLOSE);
 191 // request.headers().set(HttpHeaders.Names.ACCEPT_ENCODING,
 192 // HttpHeaders.Values.GZIP);
 193 //
 194 // request.headers().set(HttpHeaders.Names.COOKIE,
 195 // ClientCookieEncoder.encode(
 196 // new DefaultCookie("my-cookie", "foo"),
 197 // new DefaultCookie("another-cookie", "bar")));
 198 //
 199 // ch.writeAndFlush(request);
 200 //
 201 // ch.closeFuture().sync();
 202 // } finally {
 203 // group.shutdownGracefully();
 204 // }
 205 // }
 206 //
 207 // }