Example usage for java.util.concurrent.atomic AtomicReference AtomicReference

List of usage examples for java.util.concurrent.atomic AtomicReference AtomicReference

  1. HOME
  2. Java
  3. java
  4. java.util.concurrent.atomic.*
  5. AtomicReference
  6. AtomicReference

Introduction

In this page you can find the example usage for java.util.concurrent.atomic AtomicReference AtomicReference.

Prototype

public AtomicReference()

Source Link

Document

Creates a new AtomicReference with null initial value.

Usage

From source file:org.hawkular.listener.cache.InventoryHelperTest.java

@Test
public void shouldListNoMetricsForTypeWhenChunksAreIncomplete() {
    // Data & mocks
    String tenant = "tenant";
    String feed = "feed";
    Metric<String> r1 = new Metric<>("inventory.123.r.r1", null, 7, MetricType.STRING, null);
    long currentTime = System.currentTimeMillis();
    when(metricsService.findMetricsWithFilters(anyString(), anyObject(), anyString()))
            .thenAnswer(invocationOnMock -> Observable.just(r1));
    DataPoint<String> tempDataPoint = buildRootResourceDatapointWithMetrics(tenant, feed, currentTime - 500,
            "r1");
    DataPoint<String> dataPoint = new DataPoint<>(tempDataPoint.getTimestamp(), tempDataPoint.getValue(),
            ImmutableMap.<String, String>builder().put("chunks", "3").put("size", "1000").build());
    when(metricsService.findStringData(r1.getMetricId(), 0, currentTime, false, 0, Order.DESC))
            .thenReturn(Observable.just(dataPoint));
    org.hawkular.inventory.api.model.MetricType.Blueprint bp = org.hawkular.inventory.api.model.MetricType.Blueprint
            .builder(MetricDataType.GAUGE).withId("metricType1").withName("Metric type 1").withInterval(60L)
            .withUnit(MetricUnit.BYTES).build();

    // Test & assertions
    AtomicReference<Throwable> refException = new AtomicReference<>();
    InventoryHelper.listMetricsForType(metricsService, tenant, feed, bp, currentTime).toList().subscribe(a -> {
    }, refException::set);// w w  w.java2s  .c  om
    Assert.assertEquals(InvalidInventoryChunksException.class, refException.get().getCause().getClass());
    Assert.assertTrue("Unexpected message: " + refException.get().getCause().getMessage(),
            refException.get().getCause().getMessage()
                    .contains("Inventory sanity check failure: 3 chunks expected, only 1 are available"));
}

From source file:com.netflix.iep.http.RxHttpTest.java

@Test
public void readTimeoutDoesntRetry() throws Exception {
    //set(client + ".niws.client.ReadTimeout", "100");
    set(client + ".niws.client.RetryReadTimeouts", "false");
    int code = 200;
    statusCode.set(code);//  w w w.j ava 2s .  co  m
    AtomicIntegerArray expected = copy(statusCounts);
    expected.addAndGet(code, 1);

    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<Throwable> throwable = new AtomicReference<>();
    rxHttp.get(uri("/readTimeout")).subscribe(Actions.empty(), new Action1<Throwable>() {
        @Override
        public void call(Throwable t) {
            throwable.set(t);
            latch.countDown();
        }
    }, new Action0() {
        @Override
        public void call() {
            latch.countDown();
        }
    });

    latch.await();
    Assert.assertTrue(throwable.get() instanceof ReadTimeoutException);
    assertEquals(expected, statusCounts);
}

From source file:com.quartercode.eventbridge.test.def.extra.extension.DefaultReturnEventExtensionReturnerTest.java

@SuppressWarnings("unchecked")
@Test//  www .j  a va2  s  . c  o  m
public void testReturnEventSenders() throws BridgeConnectorException {

    ToStringBuilder.setDefaultStyle(ToStringStyle.SHORT_PREFIX_STYLE);

    final BridgeConnector source1 = null;
    final BridgeConnector source2 = context.mock(BridgeConnector.class, "source2");
    final BridgeConnector source3 = context.mock(BridgeConnector.class, "source3");

    final EmptyEvent1 returnEvent1 = new EmptyEvent1();
    final EmptyEvent2 returnEvent2 = new EmptyEvent2();
    final EmptyEvent3 returnEvent3 = new EmptyEvent3();
    final ReturnEventExtensionWrapper returnEvent1Wrapper = new ReturnEventExtensionWrapper(returnEvent1, 0,
            false);
    final ReturnEventExtensionWrapper returnEvent2Wrapper = new ReturnEventExtensionWrapper(returnEvent2, 1,
            false);
    final ReturnEventExtensionWrapper returnEvent3Wrapper = new ReturnEventExtensionWrapper(returnEvent3, 2,
            false);

    final RequestHandleInterceptor interceptor = context.mock(RequestHandleInterceptor.class);
    extension.getRequestHandleChannel().addInterceptor(new DummyRequestHandleInterceptor(interceptor), 1);

    final RequestEventHandler<Event> handler = context.mock(RequestEventHandler.class, "handler");
    final EventPredicate<Event> predicate = context.mock(EventPredicate.class, "predicate");
    final EventPredicate<?> wrapperPredicate = new ReturnEventExtensionWrapperPredicate(predicate);

    final AtomicReference<LowLevelHandler> lowLevelHandler = new AtomicReference<>();
    final AtomicReference<ReturnEventSender> returnEventSender1FromInterceptor = new AtomicReference<>();
    final AtomicReference<ReturnEventSender> returnEventSender2FromInterceptor = new AtomicReference<>();
    final AtomicReference<ReturnEventSender> returnEventSender3FromInterceptor = new AtomicReference<>();
    final AtomicReference<ReturnEventSender> returnEventSender1FromHandler = new AtomicReference<>();
    final AtomicReference<ReturnEventSender> returnEventSender2FromHandler = new AtomicReference<>();
    final AtomicReference<ReturnEventSender> returnEventSender3FromHandler = new AtomicReference<>();

    // @formatter:off
    context.checking(new Expectations() {
        {

            oneOf(lowLevelHandlerModule).addHandler(with(aLowLevelHandlerWithThePredicate(wrapperPredicate)));
            will(storeArgument(0).in(lowLevelHandler));

            final Sequence interceptorCalls = context.sequence("interceptorCalls");
            oneOf(interceptor).handleRequest(with(any(ChannelInvocation.class)), with(any(EmptyEvent1.class)),
                    with(source1), with(handler), with(any(ReturnEventSender.class)));
            inSequence(interceptorCalls);
            will(storeArgument(4).in(returnEventSender1FromInterceptor));
            oneOf(interceptor).handleRequest(with(any(ChannelInvocation.class)), with(any(EmptyEvent2.class)),
                    with(source2), with(handler), with(any(ReturnEventSender.class)));
            inSequence(interceptorCalls);
            will(storeArgument(4).in(returnEventSender2FromInterceptor));
            oneOf(interceptor).handleRequest(with(any(ChannelInvocation.class)), with(any(EmptyEvent3.class)),
                    with(source3), with(handler), with(any(ReturnEventSender.class)));
            inSequence(interceptorCalls);
            will(storeArgument(4).in(returnEventSender3FromInterceptor));

            final Sequence handlerCalls = context.sequence("handlerCalls");
            oneOf(handler).handle(with(any(EmptyEvent1.class)), with(any(ReturnEventSender.class)));
            inSequence(handlerCalls);
            will(storeArgument(1).in(returnEventSender1FromHandler));
            oneOf(handler).handle(with(any(EmptyEvent2.class)), with(any(ReturnEventSender.class)));
            inSequence(handlerCalls);
            will(storeArgument(1).in(returnEventSender2FromHandler));
            oneOf(handler).handle(with(any(EmptyEvent3.class)), with(any(ReturnEventSender.class)));
            inSequence(handlerCalls);
            will(storeArgument(1).in(returnEventSender3FromHandler));

            final Sequence returnSenderCalls = context.sequence("returnSenderCalls");
            oneOf(bridge).handle(returnEvent1Wrapper, source1);
            inSequence(returnSenderCalls);
            oneOf(source2).send(returnEvent2Wrapper);
            inSequence(handlerCalls);
            // Test exception suppression
            oneOf(source3).send(returnEvent3Wrapper);
            inSequence(handlerCalls);
            will(throwException(new BridgeConnectorException(source3)));

        }
    });
    // @formatter:on

    extension.addRequestHandler(handler, predicate);

    lowLevelHandler.get().handle(new ReturnEventExtensionWrapper(new EmptyEvent1(), 0, true), source1);
    lowLevelHandler.get().handle(new ReturnEventExtensionWrapper(new EmptyEvent2(), 1, true), source2);
    lowLevelHandler.get().handle(new ReturnEventExtensionWrapper(new EmptyEvent3(), 2, true), source3);

    assertTrue("Return event sender changes over time",
            returnEventSender1FromInterceptor.get() == returnEventSender1FromHandler.get());
    assertTrue("Return event sender changes over time",
            returnEventSender2FromInterceptor.get() == returnEventSender2FromHandler.get());
    assertTrue("Return event sender changes over time",
            returnEventSender3FromInterceptor.get() == returnEventSender3FromHandler.get());

    returnEventSender1FromInterceptor.get().send(returnEvent1);
    returnEventSender2FromInterceptor.get().send(returnEvent2);
    returnEventSender3FromInterceptor.get().send(returnEvent3);
}

From source file:io.atomix.protocols.gossip.map.AntiEntropyMapDelegate.java

@Override
public V compute(K key, BiFunction<? super K, ? super V, ? extends V> recomputeFunction) {
    checkState(!closed, destroyedMessage);
    checkNotNull(key, ERROR_NULL_KEY);// w ww  .j av a 2  s.c  o m
    checkNotNull(recomputeFunction, "Recompute function cannot be null");

    String encodedKey = encodeKey(key);
    AtomicReference<MapDelegateEvent.Type> update = new AtomicReference<>();
    AtomicReference<MapValue> previousValue = new AtomicReference<>();
    MapValue computedValue = items.compute(encodedKey, (k, mv) -> {
        previousValue.set(mv);
        V newRawValue = recomputeFunction.apply(key, mv == null ? null : mv.get(this::decodeValue));
        byte[] newEncodedValue = encodeValue(newRawValue);
        if (mv != null && Arrays.equals(newEncodedValue, mv.get())) {
            // value was not updated
            return mv;
        }
        MapValue newValue = new MapValue(newEncodedValue,
                timestampProvider.get(Maps.immutableEntry(key, newRawValue)));
        if (mv == null) {
            update.set(INSERT);
            return newValue;
        } else if (newValue.isNewerThan(mv)) {
            update.set(UPDATE);
            return newValue;
        } else {
            return mv;
        }
    });
    if (update.get() != null) {
        notifyPeers(new UpdateEntry(encodedKey, computedValue), peerUpdateFunction
                .select(Maps.immutableEntry(key, computedValue.get(this::decodeValue)), membershipService));
        MapDelegateEvent.Type updateType = computedValue.isTombstone() ? REMOVE : update.get();
        V value = computedValue.isTombstone()
                ? previousValue.get() == null ? null : previousValue.get().get(this::decodeValue)
                : computedValue.get(this::decodeValue);
        if (value != null) {
            notifyListeners(new MapDelegateEvent<>(updateType, key, value));
        }
        return value;
    }
    return computedValue.get(this::decodeValue);
}

From source file:sparklr.common.AbstractAuthorizationCodeProviderTests.java

private void verifyAuthorizationPage(OAuth2RestTemplate restTemplate, String location) {
    final AtomicReference<String> confirmationPage = new AtomicReference<String>();
    AuthorizationCodeAccessTokenProvider provider = new AuthorizationCodeAccessTokenProvider() {
        @Override/* w w w .  j a va 2s.c o m*/
        protected ResponseExtractor<ResponseEntity<Void>> getAuthorizationResponseExtractor() {
            return new ResponseExtractor<ResponseEntity<Void>>() {
                public ResponseEntity<Void> extractData(ClientHttpResponse response) throws IOException {
                    confirmationPage
                            .set(StreamUtils.copyToString(response.getBody(), Charset.forName("UTF-8")));
                    return new ResponseEntity<Void>(response.getHeaders(), response.getStatusCode());
                }
            };
        }
    };
    try {
        provider.obtainAuthorizationCode(restTemplate.getResource(),
                restTemplate.getOAuth2ClientContext().getAccessTokenRequest());
    } catch (UserApprovalRequiredException e) {
        // ignore
    }
    String page = confirmationPage.get();
    verifyAuthorizationPage(page);
}

From source file:com.microsoft.tfs.core.clients.versioncontrol.internal.WebServiceLayerLocalWorkspaces.java

/**
 * If the workspace name and owner provided correspond to a local workspace
 * on this computer, that local workspace will be reconciled.
 *///from ww  w. jav a  2  s. c o m
protected Workspace reconcileIfLocal(final String workspaceName, final String ownerName,
        final boolean unscannedReconcile, final boolean reconcileMissingLocalItems,
        final boolean skipIfAccessDenied, final AtomicBoolean reconciled) {
    if (reconciled != null) {
        reconciled.set(false);
    }

    if (workspaceName == null || workspaceName.length() == 0 || ownerName == null || ownerName.length() == 0) {
        return null;
    }

    Workspace localWorkspace = null;

    if ((localWorkspace = getLocalWorkspace(workspaceName, ownerName)) != null) {
        final AtomicReference<Failure[]> failures = new AtomicReference<Failure[]>();
        final AtomicBoolean pendingChangesUpdatedByServer = new AtomicBoolean();

        try {
            final boolean wasReconciled = LocalDataAccessLayer.reconcileLocalWorkspace(localWorkspace, this,
                    unscannedReconcile, reconcileMissingLocalItems, failures, pendingChangesUpdatedByServer);

            if (wasReconciled) {
                localWorkspace.invalidateMappings();
                localWorkspace.refreshMappingsIfNeeded();
            }

            if (reconciled != null) {
                reconciled.set(wasReconciled);
            }
        } catch (final ResourceAccessException e) {
            if (!skipIfAccessDenied) {
                throw e;
            }

            return null;
        }

        getVersionControlClient().reportFailures(localWorkspace, failures.get());
    }

    return localWorkspace;
}

From source file:com.netflix.iep.http.RxHttpTest.java

@Test
public void connectTimeout() throws Exception {
    // Pick a free port with no server running
    ServerSocket ss = new ServerSocket(0);
    int serverPort = ss.getLocalPort();
    ss.close();/*from w  ww .  j  a  v a 2  s  .  c  om*/

    set(client + ".niws.client.ConnectTimeout", "100");
    int code = 200;
    statusCode.set(code);

    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<Throwable> throwable = new AtomicReference<>();
    rxHttp.get("niws://test/http://localhost:" + serverPort + "/empty").subscribe(Actions.empty(),
            new Action1<Throwable>() {
                @Override
                public void call(Throwable t) {
                    throwable.set(t);
                    latch.countDown();
                }
            }, new Action0() {
                @Override
                public void call() {
                    latch.countDown();
                }
            });

    latch.await();
    Assert.assertTrue(throwable.get() instanceof ConnectException);
}

From source file:de.schildbach.pte.AbstractEfaProvider.java

protected SuggestLocationsResult xmlStopfinderRequest(final Location constraint) throws IOException {
    final HttpUrl.Builder url = stopFinderEndpoint.newBuilder();
    appendStopfinderRequestParameters(url, constraint, "XML");
    final AtomicReference<SuggestLocationsResult> result = new AtomicReference<>();

    final HttpClient.Callback callback = new HttpClient.Callback() {
        @Override//  w  ww.  ja v  a2s .  c  om
        public void onSuccessful(final CharSequence bodyPeek, final ResponseBody body) throws IOException {
            try {
                final XmlPullParser pp = parserFactory.newPullParser();
                pp.setInput(body.byteStream(), null); // Read encoding from XML declaration
                final ResultHeader header = enterItdRequest(pp);

                final List<SuggestedLocation> locations = new ArrayList<>();

                XmlPullUtil.enter(pp, "itdStopFinderRequest");

                processItdOdv(pp, "sf", new ProcessItdOdvCallback() {
                    @Override
                    public void location(final String nameState, final Location location,
                            final int matchQuality) {
                        locations.add(new SuggestedLocation(location, matchQuality));
                    }
                });

                XmlPullUtil.skipExit(pp, "itdStopFinderRequest");

                result.set(new SuggestLocationsResult(header, locations));
            } catch (final XmlPullParserException x) {
                throw new ParserException("cannot parse xml: " + bodyPeek, x);
            }
        }
    };

    if (httpPost)
        httpClient.getInputStream(callback, url.build(), url.build().encodedQuery(),
                "application/x-www-form-urlencoded", httpReferer);
    else
        httpClient.getInputStream(callback, url.build(), httpReferer);

    return result.get();
}

From source file:com.wk.lodge.composite.web.tomcat.IntegrationCompositeTests.java

@Test
public void testSync() throws Exception {
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<Throwable> failure = new AtomicReference<>();

    URI uri = new URI("ws://localhost:" + port + "/composite");
    WebSocketStompClient stompClient = new WebSocketStompClient(uri, this.headers, sockJsClient);
    stompClient.setMessageConverter(new MappingJackson2MessageConverter());

    stompClient.connect(new StompMessageHandler() {

        private StompSession stompSession;

        @Override/*from w  ww .j  a  v  a2 s .  co m*/
        public void afterConnected(StompSession stompSession, StompHeaderAccessor headers) {
            this.stompSession = stompSession;
            this.stompSession.subscribe("/user/queue/device", null);

            try {
                SyncMessage sync = new SyncMessage();
                sync.setType("sync");
                sync.setTime(new Date().getTime());
                stompSession.send("/app/sync", sync);
            } catch (Throwable t) {
                failure.set(t);
                latch.countDown();
            }
        }

        @Override
        public void handleMessage(Message<byte[]> message) {
            try {
                String json = parseMessageJson(message);
                new JsonPathExpectationsHelper("type").assertValue(json, "sync");
                new JsonPathExpectationsHelper("time").exists(json);
            } catch (Throwable t) {
                failure.set(t);
            } finally {
                this.stompSession.disconnect();
                latch.countDown();
            }
        }

        @Override
        public void handleError(Message<byte[]> message) {
            StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
            String error = "[Producer] " + accessor.getShortLogMessage(message.getPayload());
            logger.error(error);
            failure.set(new Exception(error));
        }

        @Override
        public void handleReceipt(String receiptId) {
        }

        @Override
        public void afterDisconnected() {
        }

    });

    if (!latch.await(10, TimeUnit.SECONDS)) {
        fail("Sync response not received");
    } else if (failure.get() != null) {
        throw new AssertionError("", failure.get());
    }

}

From source file:info.archinnov.achilles.test.integration.tests.AsyncQueryIT.java

@Test
public void should_query_async_with_default_params() throws Exception {
    long partitionKey = RandomUtils.nextLong(0, Long.MAX_VALUE);
    final CountDownLatch latch1 = new CountDownLatch(1);
    AchillesFuture<List<ClusteredEntity>> futureEntities = asyncManager.sliceQuery(ClusteredEntity.class)
            .forSelect().withPartitionComponents(partitionKey).fromClusterings(1, "name2")
            .toClusterings(1, "name4").withAsyncListeners(countDownLatch(latch1)).get();

    latch1.await();/*from  ww  w.j  ava  2s.co m*/

    List<ClusteredEntity> entities = futureEntities.get();
    assertThat(entities).isEmpty();

    final CountDownLatch latch2 = new CountDownLatch(1);
    final AtomicReference<Object> successSpy = new AtomicReference<>();

    FutureCallback<Object> successCallBack = new FutureCallback<Object>() {
        @Override
        public void onSuccess(Object result) {
            successSpy.getAndSet(result);
            latch2.countDown();
        }

        @Override
        public void onFailure(Throwable t) {
            latch2.countDown();
        }
    };

    String clusteredValuePrefix = insertValues(partitionKey, 1, 5);

    futureEntities = asyncManager.sliceQuery(ClusteredEntity.class).forSelect()
            .withPartitionComponents(partitionKey).fromClusterings(1, "name2").toClusterings(1, "name4")
            .withAsyncListeners(successCallBack).get();

    latch2.await();

    entities = futureEntities.get();

    assertThat(entities).hasSize(3);

    assertThat(entities.get(0).getValue()).isEqualTo(clusteredValuePrefix + 2);
    assertThat(entities.get(0).getId().getId()).isEqualTo(partitionKey);
    assertThat(entities.get(0).getId().getCount()).isEqualTo(1);
    assertThat(entities.get(0).getId().getName()).isEqualTo("name2");
    assertThat(entities.get(1).getValue()).isEqualTo(clusteredValuePrefix + 3);
    assertThat(entities.get(1).getId().getId()).isEqualTo(partitionKey);
    assertThat(entities.get(1).getId().getCount()).isEqualTo(1);
    assertThat(entities.get(1).getId().getName()).isEqualTo("name3");
    assertThat(entities.get(2).getValue()).isEqualTo(clusteredValuePrefix + 4);
    assertThat(entities.get(2).getId().getId()).isEqualTo(partitionKey);
    assertThat(entities.get(2).getId().getCount()).isEqualTo(1);
    assertThat(entities.get(2).getId().getName()).isEqualTo("name4");

    assertThat(successSpy.get()).isNotNull().isInstanceOf(List.class);
    List<CompleteBean> raws = (List<CompleteBean>) successSpy.get();
    assertThat(raws).hasSize(3);
    assertThat(raws.get(0)).isNotInstanceOf(Factory.class);

}