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

Introduction

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

Prototype

public final V get()

Source Link

Document

Returns the current value, with memory effects as specified by VarHandle#getVolatile .

Usage

From source file:com.nokia.dempsy.mpcluster.zookeeper.ZookeeperSession.java

private synchronized void resetZookeeper(ZooKeeper failedInstance) {
    AtomicReference<ZooKeeper> tmpZkRef = zkref;
    // if we're not shutting down (which would be indicated by tmpZkRef == null
    //   and if the failedInstance we're trying to reset is the current one, indicated by tmpZkRef.get() == failedInstance
    //   and if we're not already working on beingReset
    if (tmpZkRef != null && tmpZkRef.get() == failedInstance && !beingReset) {
        beingReset = true;/*from  w w  w  . j a v  a2  s.  c o m*/
        scheduler.schedule(new Runnable() {
            @Override
            public void run() {
                ZooKeeper newZk = null;
                try {
                    newZk = makeZookeeperInstance(connectString, sessionTimeout);
                } catch (IOException e) {
                    logger.warn("Failed to reset the ZooKeeper connection to " + connectString);
                    newZk = null;
                } finally {
                    if (newZk == null && isRunning)
                        // reschedule me.
                        scheduler.schedule(this, resetDelay, TimeUnit.MILLISECONDS);
                }

                // this is true if the reset worked and we're not in the process
                // of shutting down.
                if (newZk != null && isRunning) {
                    // we want the setNewZookeeper and the clearing of the
                    // beingReset flag to be atomic so future failures that result
                    // in calls to resetZookeeper will either:
                    //   1) be skipped because they are for an older ZooKeeper instance.
                    //   2) be executed because they are for this new ZooKeeper instance.
                    // what we dont want is the possibility that the reset will be skipped
                    // even though the reset is called for this new ZooKeeper, but we haven't cleared
                    // the beingReset flag yet.
                    synchronized (ZookeeperSession.this) {
                        setNewZookeeper(newZk);
                        beingReset = false;
                    }

                    // now reset the watchers
                    Set<ZookeeperCluster> clustersToReset = new HashSet<ZookeeperCluster>();
                    synchronized (cachedClusters) {
                        clustersToReset.addAll(cachedClusters.values());
                    }

                    for (ZookeeperCluster cluster : clustersToReset)
                        initializeCluster(cluster, true);
                } else if (newZk != null) {
                    // in this case with zk == null we're shutting down.
                    try {
                        newZk.close();
                    } catch (Throwable th) {
                    }
                }
            }
        }, resetDelay, TimeUnit.MILLISECONDS);
    }
}

From source file:com.networknt.basicauth.BasicAuthHandlerTest.java

@Test
public void testInvalidBasicHeaderPrefixText() throws Exception {
    final Http2Client client = Http2Client.getInstance();
    final CountDownLatch latch = new CountDownLatch(1);
    final ClientConnection connection;
    try {/*w w  w.j  a v a2 s .  c  o m*/
        connection = client.connect(new URI("http://localhost:17352"), Http2Client.WORKER, Http2Client.SSL,
                Http2Client.BUFFER_POOL, OptionMap.EMPTY).get();
    } catch (Exception e) {
        throw new ClientException(e);
    }
    final AtomicReference<ClientResponse> reference = new AtomicReference<>();
    try {
        ClientRequest request = new ClientRequest().setPath("/v2/pet").setMethod(Methods.GET);
        request.getRequestHeaders().put(Headers.HOST, "localhost");
        request.getRequestHeaders().put(Headers.AUTHORIZATION,
                "Bearer " + encodeCredentials("user1", "user1pass"));
        connection.sendRequest(request, client.createClientCallback(reference, latch));
        latch.await();
    } catch (Exception e) {
        logger.error("Exception: ", e);
        throw new ClientException(e);
    } finally {
        IoUtils.safeClose(connection);
    }
    int statusCode = reference.get().getResponseCode();
    Assert.assertEquals(401, statusCode);
    if (statusCode == 401) {
        Status status = Config.getInstance().getMapper()
                .readValue(reference.get().getAttachment(Http2Client.RESPONSE_BODY), Status.class);
        Assert.assertNotNull(status);
        Assert.assertEquals("ERR10046", status.getCode());
    }
}

From source file:com.google.code.jahath.common.io.SwappableInputStreamTest.java

@Test
public void test() throws Throwable {
    final SwappableInputStream swappableInputStream = new SwappableInputStream("test");
    final CRC actualCRC = new CRC();
    final AtomicReference<Throwable> thrown = new AtomicReference<Throwable>();
    Thread thread = new Thread(new Runnable() {
        public void run() {
            try {
                actualCRC.update(swappableInputStream);
            } catch (Throwable ex) {
                thrown.set(ex);//from  ww w.  ja va2s.c  o  m
            }
        }
    });
    thread.start();
    Random random = new Random();
    CRC expectedCRC = new CRC();
    for (int i = 0; i < 100; i++) {
        int len = 2048 + random.nextInt(4096);
        byte[] data = new byte[len];
        random.nextBytes(data);
        expectedCRC.update(data);
        CountingInputStream in = new CountingInputStream(new ByteArrayInputStream(data));
        swappableInputStream.swap(in);
        // Check that the stream has been consumed entirely
        Assert.assertEquals(len, in.getCount());
    }
    swappableInputStream.sendEndOfStream();
    thread.join();
    if (thrown.get() != null) {
        throw thrown.get();
    }
    Assert.assertEquals(expectedCRC.getValue(), actualCRC.getValue());
}

From source file:com.networknt.basicauth.BasicAuthHandlerTest.java

@Test
public void testInvalidBasicHeaderCredentialInfo() throws Exception {
    final Http2Client client = Http2Client.getInstance();
    final CountDownLatch latch = new CountDownLatch(1);
    final ClientConnection connection;
    try {//from  w ww.  ja  v a2  s .  com
        connection = client.connect(new URI("http://localhost:17352"), Http2Client.WORKER, Http2Client.SSL,
                Http2Client.BUFFER_POOL, OptionMap.EMPTY).get();
    } catch (Exception e) {
        throw new ClientException(e);
    }
    final AtomicReference<ClientResponse> reference = new AtomicReference<>();
    try {
        ClientRequest request = new ClientRequest().setPath("/v2/pet").setMethod(Methods.GET);
        request.getRequestHeaders().put(Headers.HOST, "localhost");
        request.getRequestHeaders().put(Headers.AUTHORIZATION,
                "BASIC " + encodeCredentialsFullFormat("user1", "user1pass", "/"));
        connection.sendRequest(request, client.createClientCallback(reference, latch));
        latch.await();
    } catch (Exception e) {
        logger.error("Exception: ", e);
        throw new ClientException(e);
    } finally {
        IoUtils.safeClose(connection);
    }
    int statusCode = reference.get().getResponseCode();
    Assert.assertEquals(401, statusCode);
    if (statusCode == 401) {
        Status status = Config.getInstance().getMapper()
                .readValue(reference.get().getAttachment(Http2Client.RESPONSE_BODY), Status.class);
        Assert.assertNotNull(status);
        Assert.assertEquals("ERR10046", status.getCode());
    }
}

From source file:com.jayway.restassured.itest.java.FilterITest.java

@Test
public void content_type_in_filter_doesnt_contain_charset_if_configured_not_to() {
    final AtomicReference<String> contentType = new AtomicReference<String>();

    given().config(RestAssuredConfig.config()
            .encoderConfig(encoderConfig().appendDefaultContentCharsetToContentTypeIfUndefined(false)))
            .filter(new Filter() {
                public Response filter(FilterableRequestSpecification requestSpec,
                        FilterableResponseSpecification responseSpec, FilterContext ctx) {
                    contentType.set(requestSpec.getRequestContentType());
                    return ctx.next(requestSpec, responseSpec);
                }//from  w  w  w  .  jav a2s .  c om
            }).formParam("firstName", "John").formParam("lastName", "Doe").when().post("/greet").then()
            .statusCode(200);

    assertThat(contentType.get(), equalTo("application/x-www-form-urlencoded"));
}

From source file:com.kixeye.chassis.support.test.hystrix.ChassisHystrixTest.java

@Test
public void testBasicHystrixCommand() throws Exception {

    final AtomicBoolean done = new AtomicBoolean(false);
    final AtomicReference<String> result = new AtomicReference<>(null);

    // kick off async command
    Observable<String> observable = new TestCommand().observe();

    // Sleep to test what happens if command finishes before subscription
    Thread.sleep(2000);/*from www .  j  a  va  2  s.  c o  m*/

    // Add handler
    observable.subscribe(new Observer<String>() {
        @Override
        public void onCompleted() {
            done.set(true);
        }

        @Override
        public void onError(Throwable e) {
            result.set("error!!");
            done.set(true);
        }

        @Override
        public void onNext(String args) {
            result.set(args);
            done.set(true);
        }
    });

    // spin until done
    while (!done.get()) {
        Thread.sleep(100);
    }

    Assert.assertEquals(resultString, result.get());
}

From source file:io.undertow.server.handlers.ChunkedResponseTrailersTestCase.java

@Test
public void sendHttpRequest() throws Exception {
    Assume.assumeFalse(DefaultServer.isH2()); //this test will still run under h2-upgrade, but will fail

    HttpGet get = new HttpGet(DefaultServer.getDefaultServerURL() + "/path");
    TestHttpClient client = new TestHttpClient();
    final AtomicReference<ChunkedInputStream> stream = new AtomicReference<>();
    client.addResponseInterceptor(new HttpResponseInterceptor() {

        public void process(final HttpResponse response, final HttpContext context) throws IOException {
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream instream = entity.getContent();
                if (instream instanceof ChunkedInputStream) {
                    stream.set(((ChunkedInputStream) instream));
                }/*from   w  w  w .  j av a 2  s.  c  om*/
            }
        }
    });
    try {
        generateMessage(1);
        HttpResponse result = client.execute(get);
        Assert.assertEquals(StatusCodes.OK, result.getStatusLine().getStatusCode());

        Assert.assertEquals(message, HttpClientUtils.readResponse(result));

        Header[] footers = stream.get().getFooters();
        Assert.assertEquals(2, footers.length);
        for (final Header header : footers) {
            if (header.getName().equals("foo")) {
                Assert.assertEquals("fooVal", header.getValue());
            } else if (header.getName().equals("bar")) {
                Assert.assertEquals("barVal", header.getValue());
            } else {
                Assert.fail("Unknown header" + header);
            }
        }

        generateMessage(1000);
        result = client.execute(get);
        Assert.assertEquals(StatusCodes.OK, result.getStatusLine().getStatusCode());
        Assert.assertEquals(message, HttpClientUtils.readResponse(result));
        footers = stream.get().getFooters();
        Assert.assertEquals(2, footers.length);
        for (final Header header : footers) {
            if (header.getName().equals("foo")) {
                Assert.assertEquals("fooVal", header.getValue());
            } else if (header.getName().equals("bar")) {
                Assert.assertEquals("barVal", header.getValue());
            } else {
                Assert.fail("Unknown header" + header);
            }
        }
    } finally {
        client.getConnectionManager().shutdown();
    }

}

From source file:com.kixeye.janus.client.http.rest.DefaultRestHttpClientTest.java

@Test
public void getParamListTest() throws Exception {
    MetricRegistry metricRegistry = new MetricRegistry();
    Janus janus = new Janus(VIP_TEST, new ConstServerList(VIP_TEST, "http://localhost:" + server1Port),
            new ZoneAwareLoadBalancer(VIP_TEST, "default", metricRegistry),
            new ServerStatsFactory(ServerStats.class, metricRegistry));
    DefaultRestHttpClient client = new DefaultRestHttpClient(janus, 0, DefaultRestHttpClient.UTF8_STRING_SER_DE,
            "text/plain");

    final AtomicReference<String> requestMethod = new AtomicReference<>(null);
    final AtomicReference<String> requestPath = new AtomicReference<>(null);

    testContainer = new Container() {
        public void handle(Request req, Response resp) {
            requestMethod.set(req.getMethod());
            requestPath.set(req.getTarget());

            try {
                resp.getByteChannel().write(ByteBuffer.wrap("goofy".getBytes(StandardCharsets.UTF_8)));
            } catch (IOException e) {
                logger.error("Unable to write to channel.");
            }/*from  w  ww  .  ja  va 2s  .co  m*/
        }
    };

    String result = client.post("/test_params/{}", null, String.class, "goofy").getBody().deserialize();
    Assert.assertEquals("POST", requestMethod.get());
    Assert.assertEquals("/test_params/goofy", requestPath.get());
    Assert.assertEquals("goofy", result);
}

From source file:nl.knaw.huc.di.tag.tagml.importer.TAGMLListener.java

private TAGMarkup removeFromOpenMarkup(MarkupNameContext ctx) {
    String markupName = ctx.name().getText();
    String extendedMarkupName = markupName;
    extendedMarkupName = withPrefix(ctx, extendedMarkupName);
    extendedMarkupName = withSuffix(ctx, extendedMarkupName);

    boolean isSuspend = ctx.prefix() != null && ctx.prefix().getText().equals(TAGML.SUSPEND_PREFIX);

    Set<String> layers = deduceLayers(ctx, markupName, extendedMarkupName);

    boolean layerSuffixNeeded = !(layers.size() == 1 && layers.iterator().next().equals(TAGML.DEFAULT_LAYER));
    String foundLayerSuffix = layerSuffixNeeded
            ? TAGML.DIVIDER//from   w w  w . j  a  v  a  2s.c  om
                    + layers.stream().filter(l -> !TAGML.DEFAULT_LAYER.equals(l)).sorted().collect(joining(","))
            : "";

    extendedMarkupName += foundLayerSuffix;
    removeFromMarkupStack2(extendedMarkupName, state.allOpenMarkup);
    TAGMarkup markup = null;
    for (String l : layers) {
        state.openMarkup.putIfAbsent(l, new ArrayDeque<>());
        Deque<TAGMarkup> markupStack = state.openMarkup.get(l);
        markup = removeFromMarkupStack(extendedMarkupName, markupStack);
        if (markup == null) {
            AtomicReference<String> emn = new AtomicReference<>(extendedMarkupName);
            boolean markupIsOpen = markupStack.stream().map(TAGMarkup::getExtendedTag)
                    .anyMatch(et -> emn.get().equals(et));
            if (!markupIsOpen) {
                errorListener.addError("%s Close tag <%s] found without corresponding open tag.",
                        errorPrefix(ctx), extendedMarkupName);
                return null;
            } else if (!isSuspend) {
                TAGMarkup expected = markupStack.peek();
                if (expected.hasTag(BRANCH)) {
                    errorListener.addBreakingError(
                            "%s Markup [%s> opened before branch %s, should not be closed in a branch.",
                            errorPrefix(ctx), extendedMarkupName, currentTextVariationState().branch + 1);
                }
                String hint = l.isEmpty() ? " Use separate layers to allow for overlap." : "";
                errorListener.addBreakingError("%s Close tag <%s] found, expected %s.%s", errorPrefix(ctx),
                        extendedMarkupName, closeTag(expected), hint);
                return null;
            } else {
                markup = removeFromMarkupStack2(extendedMarkupName, markupStack);
            }
        }
        document.closeMarkupInLayer(markup, l);
    }
    // for the last closing tag, close the markup for the default layer
    if (!layers.contains(DEFAULT_LAYER) && markup.getLayers().contains(DEFAULT_LAYER)) {
        Deque<TAGMarkup> markupDeque = state.openMarkup.get(DEFAULT_LAYER);
        removeFromMarkupStack(extendedMarkupName, markupDeque);
        document.closeMarkupInLayer(markup, DEFAULT_LAYER);
    }

    PrefixContext prefixNode = ctx.prefix();
    if (prefixNode != null) {
        String prefixNodeText = prefixNode.getText();
        if (prefixNodeText.equals(OPTIONAL_PREFIX)) {
            // optional
            // TODO

        } else if (prefixNodeText.equals(SUSPEND_PREFIX)) {
            // suspend
            for (String l : layers) {
                state.suspendedMarkup.putIfAbsent(l, new ArrayDeque<>());
                state.suspendedMarkup.get(l).add(markup);
            }
        }
    }
    state.eof = (markup.getDbId().equals(state.rootMarkupId));
    if (isSuspend && state.eof) {
        TAGMarkup rootMarkup = store.getMarkup(state.rootMarkupId);
        errorListener.addBreakingError("%s The root markup %s cannot be suspended.", errorPrefix(ctx),
                rootMarkup);
    }
    return markup;
}