Refine search
future.awaitUninterruptibly(); if (future.isSuccess()) { final Channel ch = future.channel(); SslHandler sslHandler = ch.pipeline().get(SslHandler.class); if (sslHandler != null) { Future<Channel> handshakeFuture = sslHandler.handshakeFuture(); if (handshakeFuture.awaitUninterruptibly(30000)) { if (handshakeFuture.isSuccess()) { ChannelPipeline channelPipeline = ch.pipeline(); ActiveMQChannelHandler channelHandler = channelPipeline.get(ActiveMQChannelHandler.class); channelHandler.active = true; } else { ch.close().awaitUninterruptibly(); ActiveMQClientLogger.LOGGER.errorCreatingNettyConnection(handshakeFuture.cause()); return null; HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, uri.getRawPath()); request.headers().set(HttpHeaderNames.HOST, ipv6Host); request.headers().set(HttpHeaderNames.UPGRADE, ACTIVEMQ_REMOTING); request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderNames.UPGRADE); final String serverName = ConfigurationHelper.getStringProperty(TransportConstants.ACTIVEMQ_SERVER_NAME, null, configuration); if (serverName != null) {
@SuppressWarnings("unused") private HttpRequest copy(String uri, HttpRequest request) { HttpRequest nue = request; if (request instanceof DefaultFullHttpRequest) { DefaultFullHttpRequest dfr = (DefaultFullHttpRequest) request; FullHttpRequest rq; try { rq = dfr.copy(); } catch (IllegalReferenceCountException e) { // Empty byteBuf rq = dfr; } rq.setUri(uri); } else { DefaultHttpRequest dfr = new DefaultHttpRequest(request.protocolVersion(), request.method(), uri); dfr.headers().set(request.headers()); nue = dfr; } return nue; } }
@Override public HttpServerRequest setExpectMultipart(boolean expect) { synchronized (conn) { checkEnded(); if (expect) { if (decoder == null) { String contentType = request.headers().get(HttpHeaderNames.CONTENT_TYPE); if (contentType != null) { HttpMethod method = request.method(); if (isValidMultipartContentType(contentType) && isValidMultipartMethod(method)) { decoder = new HttpPostRequestDecoder(new NettyFileUploadDataFactory(conn.getContext(), this, () -> uploadHandler), request); } } } } else { decoder = null; } return this; } }
HttpServerResponseImpl(final VertxInternal vertx, Http1xServerConnection conn, DefaultHttpRequest request, Object requestMetric) { this.vertx = vertx; this.conn = conn; this.version = request.protocolVersion(); this.headers = new VertxHttpHeaders(); this.status = HttpResponseStatus.OK; this.requestMetric = requestMetric; this.keepAlive = (version == HttpVersion.HTTP_1_1 && !request.headers().contains(io.vertx.core.http.HttpHeaders.CONNECTION, HttpHeaders.CLOSE, true)) || (version == HttpVersion.HTTP_1_0 && request.headers().contains(io.vertx.core.http.HttpHeaders.CONNECTION, HttpHeaders.KEEP_ALIVE, true)); this.head = request.method() == io.netty.handler.codec.http.HttpMethod.HEAD; }
private HttpRequest createRequest(HttpMethod method, String rawMethod, String uri, MultiMap headers) { DefaultHttpRequest request = new DefaultHttpRequest(HttpUtils.toNettyHttpVersion(conn.version), HttpUtils.toNettyHttpMethod(method, rawMethod), uri, false); if (headers != null) { for (Map.Entry<String, String> header : headers) { // Todo : multi valued headers request.headers().add(header.getKey(), header.getValue()); } } return request; }
try { future = bootstrap.clone().connect(new InetSocketAddress(host, port)) .addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE); Channel channel = future.awaitUninterruptibly().channel(); if (!future.isSuccess()) { endFetch(FetcherState.FETCH_FAILED); String query = eachURI.getPath() + (eachURI.getRawQuery() != null ? "?" + eachURI.getRawQuery() : ""); HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, query); request.headers().set(HttpHeaders.Names.HOST, host); request.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE); request.headers().set(HttpHeaders.Names.ACCEPT_ENCODING, HttpHeaders.Values.GZIP); channel.writeAndFlush(request); channel.closeFuture().syncUninterruptibly(); if(future != null && future.channel().isOpen()){ future.channel().close().awaitUninterruptibly();
@Override public void clear() { DefaultHttpRequest delete = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.DELETE, path); try { Channel ch = bootstrap.connect(configuration.host(), configuration.port()).awaitUninterruptibly().channel().pipeline().addLast(new HttpResponseHandler()).channel(); ch.writeAndFlush(delete).sync().channel().closeFuture().sync(); } catch (Exception e) { throw new PersistenceException(e); } }
.addListener(ChannelFutureListener.CLOSE_ON_FAILURE); Channel channel = future.await().channel(); if (!future.isSuccess()) { HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.DELETE, "ebid=" + clearEbId.toString()); request.headers().set(Names.HOST, connInfo.getHost()); request.headers().set(Names.CONNECTION, Values.CLOSE); channel.writeAndFlush(request); } catch (InterruptedException e) { throw new RuntimeException(e); } finally { if (future != null && future.channel().isOpen()) { future.channel().close();
.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) .connect(InetSocketAddress.createUnresolved(host, port)) .addListener((ChannelFutureListener) future -> { if (future.isSuccess()) { String path = uri.getRawPath() + (uri.getRawQuery() == null ? "" : "?" + uri.getRawQuery()); HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, path); request.headers().set(HttpHeaderNames.HOST, host); future.channel().writeAndFlush(request); } else { callback.error(future.cause());
final Channel ch = b.connect(host, port).sync().channel(); ch.closeFuture().addListener(closeListener); nettyRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(jerseyRequest.getMethod()), requestUri.getRawPath()); } else { nettyRequest.headers().add(e.getKey(), e.getValue());
@Override public int size() { Channel ch = null; DefaultHttpRequest get = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, path + "?global"); get.headers().add(HttpHeaders.Names.ACCEPT, "text/plain"); try { HttpResponseHandler handler = new HttpResponseHandler(true); ch = bootstrap.connect(configuration.host(), configuration.port()).awaitUninterruptibly().channel().pipeline().addLast( new HttpObjectAggregator(maxContentLength), handler).channel(); ch.writeAndFlush(get).sync().channel().closeFuture().sync(); try { BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(new ByteBufInputStream(((FullHttpResponse) handler.getResponse()).content()))); int count = 0; while (reader.readLine() != null) count++; return count; } finally { reader.close(); } } finally { handler.getResponse().release(); } } catch (Exception e) { throw log.errorLoadingRemoteEntries(e); } }
HttpClientOperations(Channel channel, BiFunction<? super HttpClientResponse, ? super HttpClientRequest, ? extends Publisher<Void>> handler, ContextHandler<?> context) { super(channel, handler, context); this.isSecure = channel.pipeline() .get(NettyPipeline.SslHandler) != null; String[] redirects = channel.attr(REDIRECT_ATTR_KEY) .get(); this.redirectedFrom = redirects == null ? EMPTY_REDIRECTIONS : redirects; this.nettyRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/"); this.requestHeaders = nettyRequest.headers(); this.requestHeaders.set(HttpHeaderNames.USER_AGENT, HttpClient.USER_AGENT); this.inboundPrefetch = 16; chunkedTransfer(true); }
sb.bind(serverAddress).sync(); Channel clientChannel = cb.connect(serverAddress).sync().channel(); assertTrue(serverChannelLatch.await(5, SECONDS)); clientChannel.writeAndFlush(new DefaultHttpRequest(HTTP_1_1, GET, "/")); assertTrue(requestLatch.await(5, SECONDS));
private HttpRequest prepareEntityRequest(String uri, Object entity, HttpMethod httpMethod) { HttpRequest request = null; if (entity != null) { FullHttpRequest fullRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, httpMethod, uri); byte[] bytes; try { ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false); bytes = objectMapper.writeValueAsBytes(entity); } catch (JsonProcessingException e) { throw new RuntimeException(e); } fullRequest.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json"); fullRequest.content().clear().writeBytes(Unpooled.copiedBuffer(bytes)); fullRequest.headers().set(HttpHeaderNames.CONTENT_LENGTH, bytes.length); request = fullRequest; } else { request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, httpMethod, uri); request.headers().set(HttpHeaderNames.CONTENT_LENGTH, 0); } setDefaultHeaders(request); return request; }
Channel channel = future.awaitUninterruptibly().getChannel(); if (!future.isSuccess()) { future.getCause().printStackTrace(); bootstrap.releaseExternalResources(); HttpRequest request = new DefaultHttpRequest( HttpVersion.HTTP_1_1, HttpMethod.GET, uri.getRawPath()); request.setHeader(HttpHeaders.Names.HOST, host); request.setHeader(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE); request.setHeader(HttpHeaders.Names.ACCEPT_ENCODING, HttpHeaders.Values.GZIP); channel.write(request); channel.getCloseFuture().awaitUninterruptibly();
public NettyRequest newNettyRequest(Request request, boolean performConnectRequest, ProxyServer proxyServer, Realm realm, Realm proxyRealm) { HttpMethod method = performConnectRequest ? HttpMethod.CONNECT : HttpMethod.valueOf(request.getMethod()); boolean connect = method == HttpMethod.CONNECT; HttpRequest httpRequest = new DefaultHttpRequest(httpVersion, method, requestUri); nettyRequest = new NettyRequest(httpRequest, body); HttpHeaders headers = nettyRequest.getHttpRequest().headers(); headers.set(PROXY_AUTHORIZATION, request.getHeaders().getAll(PROXY_AUTHORIZATION)); headers.set(request.getHeaders());
String contentEncoding = headers.get(HttpHeaderNames.CONTENT_ENCODING); if (contentEncoding != null) { contentEncoding = contentEncoding.trim(); if (headers.contains(HttpHeaderNames.CONTENT_LENGTH)) { headers.remove(HttpHeaderNames.CONTENT_LENGTH); headers.set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED); if (message instanceof HttpRequest) { copy = new DefaultHttpRequest(r.protocolVersion(), r.method(), r.uri()); } else if (message instanceof HttpResponse) {
HttpRequest httpRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_1, etcdRequest.getMethod(), uri); httpRequest.headers().add(HttpHeaderNames.CONNECTION, "keep-alive"); if(!this.config.hasHostName()) { httpRequest.headers().add(HttpHeaderNames.HOST, server.getHost() + ':' + server.getPort()); } else { httpRequest.headers().add(HttpHeaderNames.HOST, this.config.getHostName()); ChannelFuture future = channel.write(httpRequest); if (bodyRequestEncoder != null && bodyRequestEncoder.isChunked()) { future = channel.write(bodyRequestEncoder); channel.flush(); return future;
@Override protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception { if (!(msg instanceof FullHttpRequest)) { DefaultHttpRequest req = (DefaultHttpRequest) msg; String upgrade = req.headers().get(HttpHeaders.Names.UPGRADE); if (HttpHeaders.Values.WEBSOCKET.equalsIgnoreCase(upgrade)) { // ensure FullHttpRequest by installing HttpObjectAggregator in front of this handler ReferenceCountUtil.retain(msg); this.configurator.switchToWebSocketsHandshake(ctx.pipeline()); ctx.pipeline().fireChannelRead(msg); } else { ReferenceCountUtil.retain(msg); this.configurator.switchToPlainHttp(ctx.pipeline()); ctx.pipeline().fireChannelRead(msg); } } else { // do the handshake FullHttpRequest req = (FullHttpRequest) msg; WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(req.getUri(), null, false); WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req); if (handshaker == null) { WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel()); } else { ChannelFuture future = handshaker.handshake(ctx.channel(), req); future.addListener(f -> { this.configurator.switchToWebSockets(ctx.pipeline()); }); } } }