@Override public void addConnectionListener(Listener listener) { nettyConnection.addConnectionListener(listener); }
@Override public void connectionClosed(Connection connection) { if (connection != null) { connection.close(); } }
@Override public Origin getOrigin() { return nettyConnection.getOrigin(); }
@Override public boolean returnConnection(Connection connection) { stats.recordTimeToFirstByte(connection.getTimeToFirstByteMillis()); if (connection.isConnected()) { Subscriber<? super Connection> subscriber = waitingSubscribers.poll(); if (subscriber != null) { subscriber.onNext(connection); subscriber.onCompleted(); } else { // todo this synchronization can probably be removed synchronized (connection) { busyConnections.decrementAndGet(); borrowedConnections.remove(connection); availableConnections.add(connection); } } } else { connectionClosedInternal(connection); } return false; }
@Override public Observable<HttpResponse> write(HttpRequest request) { return nettyConnection.write(request); }
private Connection getNextActiveConnectionCloseOnDeadConnection() { Connection connection = availableConnections.poll(); while (connection != null && !connection.isConnected()) { connection = this.availableConnections.poll(); } return connection; }
@Override public long getTimeToFirstByteMillis() { return nettyConnection.getTimeToFirstByteMillis(); }
Observable<HttpResponse> observableResponse = connection.flatMap(tConnection -> { connectionRef.set(tConnection); return tConnection.write(request) .map(response -> addOriginId(originId, response)); });
@Override public boolean isConnected() { if (isExpired()) { close(); return false; } return nettyConnection.isConnected(); }
@Override public void close() { nettyConnection.close(); }
private Observable<Connection> createConnection() { connectionAttempts.incrementAndGet(); return connectionFactory.createConnection(origin, connectionPoolSettings) .doOnError(throwable -> { busyConnections.decrementAndGet(); connectionFailures.incrementAndGet(); }) .map(connection -> { connection.addConnectionListener(SimpleConnectionPool.this); borrowedConnections.add(connection); return connection; }); }
@Override public Observable<HttpResponse> sendRequest(HttpRequest request) { HttpRequest networkRequest = addUserAgent(request); Origin origin = originFromRequest(networkRequest); ConnectionDestination connectionDestination = connectionDestination(origin); Observable<HttpResponse> response = connectionDestination.withConnection(connection -> connection.write(networkRequest)); return new HttpTransaction.NonCancellableHttpTransaction(response).response(); }
private Observable<Connection> createConnection() { return connectionFactory.createConnection(origin, connectionSettings) .doOnNext(connection -> connection.addConnectionListener(CloseAfterUseConnectionDestination.this)); }
@Override public boolean closeConnection(Connection connection) { boolean removed = borrowedConnections.remove(connection); if (removed) { busyConnections.decrementAndGet(); closedConnections.incrementAndGet(); connection.close(); } return true; }
@Override public <T> Observable<T> withConnection(Function<Connection, Observable<T>> task) { return createConnection() .flatMap(connection -> execute(task, connection) .doOnCompleted(connection::close) .doOnError(throwable -> connection.close())); }