List of usage examples for java.util.concurrent.atomic AtomicInteger decrementAndGet
public final int decrementAndGet()
From source file:org.apache.bookkeeper.mledger.impl.ManagedLedgerImpl.java
private void initializeCursors(final ManagedLedgerInitializeLedgerCallback callback) { if (log.isDebugEnabled()) { log.debug("[{}] initializing cursors", name); }//from w w w. j a v a2 s . co m store.getCursors(name, new MetaStoreCallback<List<String>>() { @Override public void operationComplete(List<String> consumers, Stat s) { // Load existing cursors final AtomicInteger cursorCount = new AtomicInteger(consumers.size()); if (log.isDebugEnabled()) { log.debug("[{}] Found {} cursors", name, consumers.size()); } if (consumers.isEmpty()) { callback.initializeComplete(); return; } for (final String cursorName : consumers) { if (log.isDebugEnabled()) { log.debug("[{}] Loading cursor {}", name, cursorName); } final ManagedCursorImpl cursor; cursor = new ManagedCursorImpl(bookKeeper, config, ManagedLedgerImpl.this, cursorName); cursor.recover(new VoidCallback() { @Override public void operationComplete() { log.info("[{}] Recovery for cursor {} completed. pos={} -- todo={}", name, cursorName, cursor.getMarkDeletedPosition(), cursorCount.get() - 1); cursor.setActive(); cursors.add(cursor); if (cursorCount.decrementAndGet() == 0) { // The initialization is now completed, register the jmx mbean callback.initializeComplete(); } } @Override public void operationFailed(ManagedLedgerException exception) { log.warn("[{}] Recovery for cursor {} failed", name, cursorName, exception); cursorCount.set(-1); callback.initializeFailed(exception); } }); } } @Override public void operationFailed(MetaStoreException e) { log.warn("[{}] Failed to get the cursors list", name, e); callback.initializeFailed(new ManagedLedgerException(e)); } }); }
From source file:org.glassfish.jersey.apache.connector.HelloWorldTest.java
/** * JERSEY-2157 reproducer.//from w ww . j a v a 2 s. co m * <p> * The test ensures that entities of the error responses which cause * WebApplicationException being thrown by a JAX-RS client are buffered * and that the underlying input connections are automatically released * in such case. */ @Test public void testConnectionClosingOnExceptionsForErrorResponses() { final BasicClientConnectionManager cm = new BasicClientConnectionManager(); final AtomicInteger connectionCounter = new AtomicInteger(0); final ClientConfig config = new ClientConfig().property(ApacheClientProperties.CONNECTION_MANAGER, new ClientConnectionManager() { @Override public SchemeRegistry getSchemeRegistry() { return cm.getSchemeRegistry(); } @Override public ClientConnectionRequest requestConnection(final HttpRoute route, final Object state) { connectionCounter.incrementAndGet(); final ClientConnectionRequest wrappedRequest = cm.requestConnection(route, state); /** * To explain the following long piece of code: * * All the code does is to just create a wrapper implementations * for the AHC connection management interfaces. * * The only really important piece of code is the * {@link org.apache.http.conn.ManagedClientConnection#releaseConnection()} implementation, * where the connectionCounter is decremented when a managed connection instance * is released by AHC runtime. In our test, this is expected to happen * as soon as the exception is created for an error response * (as the error response entity gets buffered in * {@link org.glassfish.jersey.client.JerseyInvocation#convertToException(javax.ws.rs.core.Response)}). */ return new ClientConnectionRequest() { @Override public ManagedClientConnection getConnection(long timeout, TimeUnit tunit) throws InterruptedException, ConnectionPoolTimeoutException { final ManagedClientConnection wrappedConnection = wrappedRequest .getConnection(timeout, tunit); return new ManagedClientConnection() { @Override public boolean isSecure() { return wrappedConnection.isSecure(); } @Override public HttpRoute getRoute() { return wrappedConnection.getRoute(); } @Override public SSLSession getSSLSession() { return wrappedConnection.getSSLSession(); } @Override public void open(HttpRoute route, HttpContext context, HttpParams params) throws IOException { wrappedConnection.open(route, context, params); } @Override public void tunnelTarget(boolean secure, HttpParams params) throws IOException { wrappedConnection.tunnelTarget(secure, params); } @Override public void tunnelProxy(HttpHost next, boolean secure, HttpParams params) throws IOException { wrappedConnection.tunnelProxy(next, secure, params); } @Override public void layerProtocol(HttpContext context, HttpParams params) throws IOException { wrappedConnection.layerProtocol(context, params); } @Override public void markReusable() { wrappedConnection.markReusable(); } @Override public void unmarkReusable() { wrappedConnection.unmarkReusable(); } @Override public boolean isMarkedReusable() { return wrappedConnection.isMarkedReusable(); } @Override public void setState(Object state) { wrappedConnection.setState(state); } @Override public Object getState() { return wrappedConnection.getState(); } @Override public void setIdleDuration(long duration, TimeUnit unit) { wrappedConnection.setIdleDuration(duration, unit); } @Override public boolean isResponseAvailable(int timeout) throws IOException { return wrappedConnection.isResponseAvailable(timeout); } @Override public void sendRequestHeader(HttpRequest request) throws HttpException, IOException { wrappedConnection.sendRequestHeader(request); } @Override public void sendRequestEntity(HttpEntityEnclosingRequest request) throws HttpException, IOException { wrappedConnection.sendRequestEntity(request); } @Override public HttpResponse receiveResponseHeader() throws HttpException, IOException { return wrappedConnection.receiveResponseHeader(); } @Override public void receiveResponseEntity(HttpResponse response) throws HttpException, IOException { wrappedConnection.receiveResponseEntity(response); } @Override public void flush() throws IOException { wrappedConnection.flush(); } @Override public void close() throws IOException { wrappedConnection.close(); } @Override public boolean isOpen() { return wrappedConnection.isOpen(); } @Override public boolean isStale() { return wrappedConnection.isStale(); } @Override public void setSocketTimeout(int timeout) { wrappedConnection.setSocketTimeout(timeout); } @Override public int getSocketTimeout() { return wrappedConnection.getSocketTimeout(); } @Override public void shutdown() throws IOException { wrappedConnection.shutdown(); } @Override public HttpConnectionMetrics getMetrics() { return wrappedConnection.getMetrics(); } @Override public InetAddress getLocalAddress() { return wrappedConnection.getLocalAddress(); } @Override public int getLocalPort() { return wrappedConnection.getLocalPort(); } @Override public InetAddress getRemoteAddress() { return wrappedConnection.getRemoteAddress(); } @Override public int getRemotePort() { return wrappedConnection.getRemotePort(); } @Override public void releaseConnection() throws IOException { connectionCounter.decrementAndGet(); wrappedConnection.releaseConnection(); } @Override public void abortConnection() throws IOException { wrappedConnection.abortConnection(); } @Override public String getId() { return wrappedConnection.getId(); } @Override public void bind(Socket socket) throws IOException { wrappedConnection.bind(socket); } @Override public Socket getSocket() { return wrappedConnection.getSocket(); } }; } @Override public void abortRequest() { wrappedRequest.abortRequest(); } }; } @Override public void releaseConnection(ManagedClientConnection conn, long keepalive, TimeUnit tunit) { cm.releaseConnection(conn, keepalive, tunit); } @Override public void closeExpiredConnections() { cm.closeExpiredConnections(); } @Override public void closeIdleConnections(long idletime, TimeUnit tunit) { cm.closeIdleConnections(idletime, tunit); } @Override public void shutdown() { cm.shutdown(); } }); config.connectorProvider(new ApacheConnectorProvider()); final Client client = ClientBuilder.newClient(config); final WebTarget rootTarget = client.target(getBaseUri()).path(ROOT_PATH); // Test that connection is getting closed properly for error responses. try { final String response = rootTarget.path("error").request().get(String.class); fail("Exception expected. Received: " + response); } catch (InternalServerErrorException isee) { // do nothing - connection should be closed properly by now } // Fail if the previous connection has not been closed automatically. assertEquals(0, connectionCounter.get()); try { final String response = rootTarget.path("error2").request().get(String.class); fail("Exception expected. Received: " + response); } catch (InternalServerErrorException isee) { assertEquals("Received unexpected data.", "Error2.", isee.getResponse().readEntity(String.class)); // Test buffering: // second read would fail if entity was not buffered assertEquals("Unexpected data in the entity buffer.", "Error2.", isee.getResponse().readEntity(String.class)); } assertEquals(0, connectionCounter.get()); }