/** * Tracks connecting to the target. * * @param secure {@code true} if the route is secure, * {@code false} otherwise */ public final void connectTarget(final boolean secure) { Asserts.check(!this.connected, "Already connected"); this.connected = true; this.secure = secure; }
/** * Tracks connecting to the target. * * @param secure {@code true} if the route is secure, * {@code false} otherwise */ public final void connectTarget(final boolean secure) { Asserts.check(!this.connected, "Already connected"); this.connected = true; this.secure = secure; }
/** * Tracks connecting to the target. * * @param secure {@code true} if the route is secure, * {@code false} otherwise */ public final void connectTarget(final boolean secure) { Asserts.check(!this.connected, "Already connected"); this.connected = true; this.secure = secure; }
private boolean queueInterestOps(final InterestOpEntry entry) { // validity checks Asserts.check(this.interestOpsQueueing, "Interest ops queueing not enabled"); if (entry == null) { return false; } // add this operation to the interestOps() queue this.interestOpsQueue.add(entry); return true; }
/** * Removes the header that was returned last. */ @Override public void remove() throws UnsupportedOperationException { Asserts.check(this.lastIndex >= 0, "No header to remove"); this.allHeaders.remove(this.lastIndex); this.lastIndex = -1; this.currentIndex--; // adjust for the removed element } }
/** * Removes the header that was returned last. */ @Override public void remove() throws UnsupportedOperationException { Asserts.check(this.lastIndex >= 0, "No header to remove"); this.allHeaders.remove(this.lastIndex); this.lastIndex = -1; this.currentIndex--; // adjust for the removed element } }
/** * Removes the header that was returned last. */ @Override public void remove() throws UnsupportedOperationException { Asserts.check(this.lastIndex >= 0, "No header to remove"); this.allHeaders.remove(this.lastIndex); this.lastIndex = -1; this.currentIndex--; // adjust for the removed element } }
@Override public void requestCompleted() { final HttpAsyncRequestProducer requestProducer = this.requestProducerRef.getAndSet(null); Asserts.check(requestProducer != null, "Inconsistent state: request producer is null"); requestProducer.requestCompleted(this.localContext); }
@Override public void requestCompleted() { final HttpAsyncRequestProducer requestProducer = this.requestProducerRef.getAndSet(null); Asserts.check(requestProducer != null, "Inconsistent state: request producer is null"); requestProducer.requestCompleted(this.localContext); }
@Override public void consumeContent( final ContentDecoder decoder, final IOControl ioctrl) throws IOException { final HttpAsyncResponseConsumer<T> responseConsumer = this.responseConsumerRef.get(); Asserts.check(responseConsumer != null, "Inconsistent state: response consumer is null"); responseConsumer.consumeContent(decoder, ioctrl); }
/** * Tracks tunnelling to the target. * * @param secure <code>true</code> if the route is secure, * <code>false</code> otherwise */ public final void tunnelTarget(final boolean secure) { Asserts.check(this.connected, "No tunnel unless connected"); Asserts.notNull(this.proxyChain, "No tunnel without proxy"); this.tunnelled = TunnelType.TUNNELLED; this.secure = secure; }
@Override public void produceContent( final ContentEncoder encoder, final IOControl ioctrl) throws IOException { final HttpAsyncRequestProducer requestProducer = this.requestProducerRef.get(); Asserts.check(requestProducer != null, "Inconsistent state: request producer is null"); requestProducer.produceContent(encoder, ioctrl); }
public void free(final E entry, final boolean reusable) { Args.notNull(entry, "Pool entry"); final boolean found = this.leased.remove(entry); Asserts.check(found, "Entry %s has not been leased from this pool", entry); if (reusable) { this.available.addFirst(entry); } }
/** * Tracks tunnelling to the target. * * @param secure {@code true} if the route is secure, * {@code false} otherwise */ public final void tunnelTarget(final boolean secure) { Asserts.check(this.connected, "No tunnel unless connected"); Asserts.notNull(this.proxyChain, "No tunnel without proxy"); this.tunnelled = TunnelType.TUNNELLED; this.secure = secure; }
public void free(final E entry, final boolean reusable) { Args.notNull(entry, "Pool entry"); final boolean found = this.leased.remove(entry); Asserts.check(found, "Entry %s has not been leased from this pool", entry); if (reusable) { this.available.addFirst(entry); } }
public void free(final E entry, final boolean reusable) { Args.notNull(entry, "Pool entry"); final boolean found = this.leased.remove(entry); Asserts.check(found, "Entry %s has not been leased from this pool", entry); if (reusable) { this.available.addFirst(entry); } }
@Override public void consumeContent( final ContentDecoder decoder, final IOControl ioctrl) throws IOException { final HttpAsyncResponseConsumer<T> responseConsumer = this.responseConsumerRef.get(); Asserts.check(responseConsumer != null, "Inconsistent state: response consumer is null"); responseConsumer.consumeContent(decoder, ioctrl); }
@Override public ListenerEndpoint listen(final SocketAddress address) { Asserts.check(this.status.compareTo(IOReactorStatus.ACTIVE) <= 0, "I/O reactor has been shut down"); final ListenerEndpointImpl request = createEndpoint(address); this.requestQueue.add(request); this.selector.wakeup(); return request; }
@Override public IndexResult index(List<Document> docs) { Asserts.notNull(docs,"Document to index should not be null."); Asserts.check(docs.size() > 0, "Should be at least one document to index."); return indexMultipleDocuments(docs, -1); }
@Override public void upgrade( final HttpClientConnection conn, final HttpRoute route, final HttpContext context) throws IOException { Args.notNull(conn, "Connection"); Args.notNull(route, "HTTP route"); Asserts.check(conn == this.conn, "Connection not obtained from this manager"); this.connectionOperator.upgrade(this.conn, route.getTargetHost(), context); }