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

List of usage examples for java.util.concurrent.atomic AtomicBoolean get

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

Introduction

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

Prototype

public final boolean get()

Source Link

Document

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

Usage

From source file:org.opennms.newts.gsod.ImportRunner.java

public void execute(String... args) throws Exception {

    CmdLineParser parser = new CmdLineParser(this);
    try {//from   w w w  .j  av  a  2s. com
        parser.parseArgument(args);
    } catch (CmdLineException e) {
        // handling of wrong arguments
        System.err.println(e.getMessage());
        parser.printUsage(System.err);
        return;
    }

    // Setup the slf4j metrics reporter
    MetricRegistry metrics = new MetricRegistry();

    final long start = System.currentTimeMillis();
    metrics.register("elapsed-seconds", new Gauge<Double>() {

        @Override
        public Double getValue() {
            return (System.currentTimeMillis() - start) / 1000.0;
        }

    });

    final ConsoleReporter reporter = ConsoleReporter.forRegistry(metrics).outputTo(System.err)
            .convertRatesTo(SECONDS).convertDurationsTo(MILLISECONDS).build();

    reporter.start(10, SECONDS);

    if (m_restUrl == null) {
        // we are using a direct importer so use a NewtsReporter for storing metrics
        NewtsReporter newtsReporter = NewtsReporter.forRegistry(metrics).name("importer")
                .convertRatesTo(SECONDS).convertDurationsTo(MILLISECONDS).build(repository());

        newtsReporter.start(1, SECONDS);
    }

    LOG.debug("Scanning {} for GSOD data files...", m_source);

    // walk the files in the directory given
    Observable<Sample> samples = fileTreeWalker(m_source.toPath()).subscribeOn(Schedulers.io())

            // set up a meter for each file processed
            .map(meter(metrics.meter("files"), Path.class))

            // report file
            .map(reportFile())

            // read all the files and convert them into lines
            .mergeMap(lines())
            // excluding the header lines
            .filter(exclude("YEARMODA"))

            // turn each line into a list of samples
            .mergeMap(samples())

            // adjust time on samples according to arguments
            .map(adjustTime())

            // meter the samples
            .map(meter(metrics.meter("samples"), Sample.class));

    Observable<List<Sample>> batches = samples
            // create batches each second or of size m_samplesPerBatch whichever comes first
            .buffer(m_samplesPerBatch);

    Observable<Boolean> doImport = m_restUrl != null ? restPoster(batches, metrics)
            : directPoster(batches, metrics);

    System.err.println("doImport = " + doImport);

    // GO!!!
    final AtomicReference<Subscription> subscription = new AtomicReference<>();
    final AtomicBoolean failed = new AtomicBoolean(false);

    final CountDownLatch latch = new CountDownLatch(1);

    Subscription s = doImport.subscribe(new Observer<Boolean>() {

        @Override
        public void onCompleted() {
            System.err.println("Finished Importing Everything!");
            reporter.report();
            latch.countDown();
            System.exit(0);
        }

        @Override
        public void onError(Throwable e) {
            failed.set(true);
            System.err.println("Error importing!");
            e.printStackTrace();
            try {
                //latch.await();
                Subscription s = subscription.get();
                if (s != null)
                    s.unsubscribe();

            } catch (Exception ex) {
                System.err.println("Failed to close httpClient!");
                ex.printStackTrace();
            } finally {
                //dumpThreads();
            }
        }

        @Override
        public void onNext(Boolean t) {
            System.err.println("Received a boolen: " + t);
        }
    });

    subscription.set(s);
    if (failed.get()) {
        s.unsubscribe();
    }
    //latch.countDown();
    System.err.println("Return from Subscribe!");

    latch.await();

    //dumpThreads();

}

From source file:cc.gospy.example.google.GoogleSpider.java

public Collection<String> getResultLinks(final String keyword, final int pageFrom, final int pageTo) {
    if (pageFrom < 1)
        throw new IllegalArgumentException(pageFrom + "<" + 1);
    if (pageFrom >= pageTo)
        throw new IllegalArgumentException(pageFrom + ">=" + pageTo);

    final AtomicInteger currentPage = new AtomicInteger(pageFrom);
    final AtomicBoolean returned = new AtomicBoolean(false);
    final Collection<String> links = new LinkedHashSet<>();
    Gospy googleSpider = Gospy.custom()/*  ww  w .  ja va  2 s.  c o  m*/
            .setScheduler(
                    Schedulers.VerifiableScheduler.custom().setExitCallback(() -> returned.set(true)).build())
            .addFetcher(Fetchers.HttpFetcher.custom()
                    .before(request -> request.setConfig(
                            RequestConfig.custom().setProxy(new HttpHost("127.0.0.1", 8118)).build()))
                    .build())
            .addProcessor(Processors.XPathProcessor.custom()
                    .extract("//*[@id='ires']/ol/div/h3/a/@href", (task, resultList, returnedData) -> {
                        resultList.forEach(a -> {
                            if (a.startsWith("/url?q=")) {
                                String link = a.substring(7);
                                int end = link.indexOf("&sa=");
                                links.add(link.substring(0, end != -1 ? end : link.length()));
                            }
                        });
                        currentPage.incrementAndGet();
                        if (pageFrom <= currentPage.get() && currentPage.get() < pageTo) {
                            return Arrays.asList(
                                    new Task(String.format("http://www.google.com/search?q=%s&start=%d&*",
                                            keyword, (currentPage.get() - 1) * 10)));
                        } else {
                            return Arrays.asList();
                        }
                    }).build())
            .build().addTask(String.format("http://www.google.com/search?q=%s&start=%d&*", keyword, pageFrom));
    googleSpider.start();
    while (!returned.get())
        ; // block until spider returned
    googleSpider.stop();
    return links;
}

From source file:com.arpnetworking.metrics.impl.ApacheHttpSinkTest.java

@Test
public void testPostFailure() throws InterruptedException {
    _wireMockRule.stubFor(WireMock.requestMatching(new RequestValueMatcher(r -> {
        // Annotations
        Assert.assertEquals(0, r.getAnnotationsCount());

        // Dimensions
        Assert.assertEquals(0, r.getDimensionsCount());

        // Samples
        Assert.assertEquals(0, r.getTimersCount());
        Assert.assertEquals(0, r.getCountersCount());
        Assert.assertEquals(0, r.getGaugesCount());
    })).willReturn(WireMock.aResponse().withStatus(400)));

    final AtomicBoolean assertionResult = new AtomicBoolean(false);
    final Semaphore semaphore = new Semaphore(0);
    final org.slf4j.Logger logger = Mockito.mock(org.slf4j.Logger.class);
    final Sink sink = new ApacheHttpSink(
            new ApacheHttpSink.Builder().setUri(URI.create("http://localhost:" + _wireMockRule.port() + PATH))
                    .setEventHandler(new AttemptCompletedAssertionHandler(assertionResult, 1, 2, false,
                            new CompletionHandler(semaphore))),
            logger);//from   w  w w.j  a  v a  2s .  c  o m

    final TsdEvent event = new TsdEvent(ANNOTATIONS, TEST_EMPTY_SERIALIZATION_TIMERS,
            TEST_EMPTY_SERIALIZATION_COUNTERS, TEST_EMPTY_SERIALIZATION_GAUGES);

    sink.record(event);
    semaphore.acquire();

    // Ensure expected handler was invoked
    Assert.assertTrue(assertionResult.get());

    // Request matcher
    final RequestPatternBuilder requestPattern = WireMock.postRequestedFor(WireMock.urlEqualTo(PATH))
            .withHeader("Content-Type", WireMock.equalTo("application/octet-stream"));

    // Assert that data was sent
    _wireMockRule.verify(1, requestPattern);
    Assert.assertTrue(_wireMockRule.findUnmatchedRequests().getRequests().isEmpty());

    // Assert that an IOException was captured
    Mockito.verify(logger)
            .error(Mockito.startsWith("Received failure response when sending metrics to HTTP endpoint; uri="));
}

From source file:com.arpnetworking.metrics.impl.ApacheHttpSinkTest.java

@Test
public void testEndpointNotAvailable() throws InterruptedException {
    _wireMockRule.stubFor(WireMock.requestMatching(new RequestValueMatcher(r -> {
        // Annotations
        Assert.assertEquals(0, r.getAnnotationsCount());

        // Dimensions
        Assert.assertEquals(0, r.getDimensionsCount());

        // Samples
        Assert.assertEquals(0, r.getTimersCount());
        Assert.assertEquals(0, r.getCountersCount());
        Assert.assertEquals(0, r.getGaugesCount());
    })).willReturn(WireMock.aResponse().withStatus(404)));

    final AtomicBoolean assertionResult = new AtomicBoolean(false);
    final Semaphore semaphore = new Semaphore(0);
    final org.slf4j.Logger logger = Mockito.mock(org.slf4j.Logger.class);
    final Sink sink = new ApacheHttpSink(
            new ApacheHttpSink.Builder().setUri(URI.create("http://localhost:" + _wireMockRule.port() + PATH))
                    .setEventHandler(new AttemptCompletedAssertionHandler(assertionResult, 1, 2, false,
                            new CompletionHandler(semaphore))),
            logger);//from ww w  .ja v a2 s .c  o m

    final TsdEvent event = new TsdEvent(ANNOTATIONS, TEST_EMPTY_SERIALIZATION_TIMERS,
            TEST_EMPTY_SERIALIZATION_COUNTERS, TEST_EMPTY_SERIALIZATION_GAUGES);

    sink.record(event);
    semaphore.acquire();

    // Ensure expected handler was invoked
    Assert.assertTrue(assertionResult.get());

    // Request matcher
    final RequestPatternBuilder requestPattern = WireMock.postRequestedFor(WireMock.urlEqualTo(PATH))
            .withHeader("Content-Type", WireMock.equalTo("application/octet-stream"));

    // Assert that data was sent
    _wireMockRule.verify(1, requestPattern);
    Assert.assertTrue(_wireMockRule.findUnmatchedRequests().getRequests().isEmpty());

    // Assert that an IOException was captured
    Mockito.verify(logger).error(
            Mockito.startsWith("Encountered failure when sending metrics to HTTP endpoint; uri="),
            Mockito.any(RuntimeException.class));
}

From source file:com.microsoft.tfs.core.clients.versioncontrol.soapextensions.PendingChange.java

/**
 * Acquires base content if the pending change is in local workspace. If
 * file is in the baseline folder, copies it from there. If not, downloads
 * it from the server.//  w w w  .  java  2s .com
 *
 * @param client
 *        the {@link VersionControlClient} to use (must not be
 *        <code>null</code>)
 * @param localFileName
 *        the local file name to copy the baseline to (must not be
 *        <code>null</code>)
 * @return true if this pending change is in local workspace, false if this
 *         is server workspace.
 * @throws VersionControlException
 *         if this is local workspace but we failed to acquire content (e.g.
 *         baseline is deleted and connection to the server failed).
 */
private boolean copyLocalBaseline(final VersionControlClient client, final String localFileName) {
    Check.notNull(client, "client"); //$NON-NLS-1$
    Check.notNull(localFileName, "localFileName"); //$NON-NLS-1$

    final AtomicBoolean handled = new AtomicBoolean(false);

    Check.isTrue(
            pendingSetName != null && pendingSetName.length() > 0 && pendingSetOwner != null
                    && pendingSetOwner.length() > 0,
            MessageFormat.format("PendingSetName or PendingSetOwner were not populated for pending change {0}", //$NON-NLS-1$
                    toString()));

    if (inShelveset || pendingSetName == null || pendingSetName.length() == 0 || pendingSetOwner == null
            || pendingSetOwner.length() == 0) {
        return handled.get();
    }

    final Workspace workspace = client.getRuntimeWorkspaceCache().tryGetWorkspace(pendingSetName,
            pendingSetOwner);
    if (workspace != null && workspace.getLocation() == WorkspaceLocation.LOCAL) {
        if (isAdd()) {
            throw new VersionControlException(
                    MessageFormat.format(Messages.getString("PendingChange.NoBaseFileForPendingChangeFormat"), //$NON-NLS-1$
                            getLocalOrServerItem()));
        }

        final LocalWorkspaceTransaction transaction = new LocalWorkspaceTransaction(workspace);
        try {
            transaction.execute(new WorkspacePropertiesLocalVersionTransaction() {
                @Override
                public void invoke(final LocalWorkspaceProperties wp, final WorkspaceVersionTable lv) {
                    final WorkspaceLocalItem lvEntry = lv.getByPendingChange(PendingChange.this);

                    if (null != lvEntry && null != lvEntry.getBaselineFileGUID()) {
                        try {
                            final boolean symlink = PropertyConstants.IS_SYMLINK
                                    .equals(PropertyUtils.selectMatching(lvEntry.getPropertyValues(),
                                            PropertyConstants.SYMBOLIC_KEY));

                            wp.copyBaselineToTarget(lvEntry.getBaselineFileGUID(), localFileName,
                                    lvEntry.getLength(), lvEntry.getHashValue(), symlink);
                            handled.set(true);
                        } catch (final Exception e) {
                            /* Could not copy the local baseline */
                        }
                    }
                }
            });
        } finally {
            try {
                transaction.close();
            } catch (final IOException e) {
                throw new VersionControlException(e);
            }
        }

        if (!handled.get()) {
            // we don't have baseline which we should have, let's hit the
            // server to get it

            // TODO we can compress and store it as a baseline
            final String serverItem = (getSourceServerItem() == null || getSourceServerItem().length() == 0)
                    ? getServerItem()
                    : getSourceServerItem();
            final int versionToDownload = isBranch() ? getSourceVersionFrom() : getVersion();

            // for pending branch we use SourceServerItem (source of
            // branch), but SourceVersionFrom (version of the source)
            // instead of Version since it's not committed

            final Item item = client.getItem(serverItem, new ChangesetVersionSpec(versionToDownload),
                    getDeletionID(), true);

            client.downloadFile(new DownloadSpec(item.getDownloadURL()), new File(localFileName), true);

            handled.set(true);
        }
    }

    return handled.get();
}

From source file:org.zodiark.subscriber.SubscriberTest.java

@Test(enabled = false)
public void sucessfulRequestForAction() throws IOException, InterruptedException {
    final CountDownLatch completed = new CountDownLatch(1);

    final ZodiarkClient wowzaClient = new ZodiarkClient.Builder().path("http://127.0.0.1:" + port).build();
    final CountDownLatch connected = new CountDownLatch(1);
    final AtomicReference<String> uuid = new AtomicReference<>();
    final AtomicReference<String> paths = new AtomicReference<>();

    // =============== Wowza

    paths.set("");
    wowzaClient.handler(new OnEnvelopHandler() {
        @Override/*from ww w . j  a  v  a  2s. c o  m*/
        public boolean onEnvelop(Envelope e) throws IOException {

            Message m = e.getMessage();
            switch (m.getPath()) {
            case Paths.WOWZA_CONNECT:
                // Connected. Listen
                uuid.set(e.getUuid());
                break;
            case Paths.SERVER_VALIDATE_OK:
                Envelope publisherOk = Envelope.newClientToServerRequest(e.getUuid(),
                        new Message(new Path(paths.get()), e.getMessage().getData()));
                wowzaClient.send(publisherOk);
                break;
            case Paths.WOWZA_OBFUSCATE:
                WowzaMessage wm = mapper.readValue(m.getData(), WowzaMessage.class);
                Envelope ok = Envelope.newClientToServerRequest(e.getUuid(),
                        new Message(new Path(Paths.WOWZA_OBFUSCATE_OK), e.getMessage().getData()));
                System.out.println("Obfuscating Subscribers");
                wowzaClient.send(ok);
            case Paths.WOWZA_DEOBFUSCATE:
                wm = mapper.readValue(m.getData(), WowzaMessage.class);
                System.out.println("De-obfuscating Subscribers");
                ok = Envelope.newClientToServerRequest(e.getUuid(),
                        new Message(new Path(Paths.WOWZA_DEOBFUSCATE_OK), e.getMessage().getData()));
                wowzaClient.send(ok);
            default:
                // ERROR
            }

            connected.countDown();
            return false;
        }
    }).open();

    Envelope wowzaConnect = Envelope.newClientToServerRequest(new Message(new Path(Paths.WOWZA_CONNECT),
            mapper.writeValueAsString(new UserPassword("wowza", "bar"))));
    wowzaClient.send(wowzaConnect);
    connected.await();

    // ================ Publisher

    final AtomicReference<PublisherResults> answer = new AtomicReference<>();
    final ZodiarkClient publisherClient = new ZodiarkClient.Builder().path("http://127.0.0.1:" + port).build();
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<String> publisherUUID = new AtomicReference<>();
    publisherClient.handler(new OnEnvelopHandler() {
        @Override
        public boolean onEnvelop(Envelope e) throws IOException {
            answer.set(mapper.readValue(e.getMessage().getData(), PublisherResults.class));
            publisherUUID.set(e.getUuid());
            latch.countDown();
            return true;
        }
    }).open();

    // ================ Publisher create the session

    Envelope createSessionMessage = Envelope.newClientToServerRequest(
            new Message(new Path(""), mapper.writeValueAsString(new UserPassword("publisherex", "bar"))));
    createSessionMessage.setFrom(new From(ActorValue.PUBLISHER));
    publisherClient.send(createSessionMessage);
    latch.await();
    assertEquals("OK", answer.get().getResults());
    answer.set(null);

    final CountDownLatch tlatch = new CountDownLatch(1);
    final AtomicReference<String> finalMessage = new AtomicReference<>();

    publisherClient.handler(new OnEnvelopHandler() {
        @Override
        public boolean onEnvelop(Envelope e) throws IOException {

            switch (e.getMessage().getPath()) {
            case Paths.BEGIN_STREAMING_SESSION:
                answer.set(mapper.readValue(e.getMessage().getData(), PublisherResults.class));
                tlatch.countDown();
                break;
            case Paths.PUBLISHER_ACTION_ACCEPT:
                Action a = mapper.readValue(e.getMessage().getData(), Action.class);
                Envelope publisherOk = Envelope.newClientToServerRequest(e.getUuid(),
                        new Message(new Path(Paths.ZODIARK_ACTION_ACCEPTED), e.getMessage().getData()));
                publisherClient.send(publisherOk);
                break;
            case Paths.ACTION_START:
                // Start action
                PublisherResults results = mapper.readValue(e.getMessage().getData(), PublisherResults.class);
                System.out.println("==> Start Action " + results.getResults());

                publisherOk = Envelope.newClientToServerRequest(e.getUuid(),
                        new Message(new Path(Paths.ACTION_START_OK), e.getMessage().getData()));
                publisherClient.send(publisherOk);
                break;
            case Paths.ACTION_TIMER:
                Time t = mapper.readValue(e.getMessage().getData(), Time.class);
                System.out.println("Publisher ===>" + t);
                break;
            case Paths.ACTION_COMPLETED:
                results = mapper.readValue(e.getMessage().getData(), PublisherResults.class);
                System.out.println("Publisher Action completed");
                completed.countDown();
                break;
            case Paths.PUBLISHER_ABOUT_READY:
                results = mapper.readValue(e.getMessage().getData(), PublisherResults.class);

                finalMessage.set(results.getResults());
                break;
            }
            return false;
        }
    });

    // ================ Prepare for streaming, handshake with Wowza

    Envelope startStreamingSession = Envelope
            .newClientToServerRequest(new Message(new Path(Paths.VALIDATE_PUBLISHER_STREAMING_SESSION),
                    mapper.writeValueAsString(new WowzaUUID(uuid.get()))));
    createSessionMessage.setFrom(new From(ActorValue.PUBLISHER));
    publisherClient.send(startStreamingSession);

    tlatch.await();

    assertEquals("OK", answer.get().getResults());

    // ================ Subscriber

    paths.set(Paths.JOIN_SUBSCRIBER_STREAMING_SESSION);
    final AtomicReference<SubscriberResults> sanswer = new AtomicReference<>();
    final ZodiarkClient subscriberClient = new ZodiarkClient.Builder().path("http://127.0.0.1:" + port).build();
    final CountDownLatch platch = new CountDownLatch(1);
    final AtomicReference<String> subscriberUUID = new AtomicReference<>();

    subscriberClient.handler(new OnEnvelopHandler() {
        @Override
        public boolean onEnvelop(Envelope e) throws IOException {
            sanswer.set(mapper.readValue(e.getMessage().getData(), SubscriberResults.class));
            subscriberUUID.set(e.getUuid());
            platch.countDown();
            return true;
        }
    }).open();

    // ================ Subscriber create the session

    createSessionMessage = Envelope.newClientToServerRequest(subscriberUUID.get(),
            new Message(new Path(Paths.DB_POST_SUBSCRIBER_SESSION_CREATE),
                    mapper.writeValueAsString(new UserPassword("123456", "bar"))));
    createSessionMessage.setFrom(new From(ActorValue.SUBSCRIBER));
    subscriberClient.send(createSessionMessage);
    platch.await();
    assertEquals("OK", sanswer.get().getResults());
    sanswer.set(null);

    final CountDownLatch elatch = new CountDownLatch(1);
    subscriberClient.handler(new OnEnvelopHandler() {
        @Override
        public boolean onEnvelop(Envelope e) throws IOException {
            sanswer.set(mapper.readValue(e.getMessage().getData(), SubscriberResults.class));
            elatch.countDown();
            return true;
        }
    });

    // ================ Join the Publisher Session

    StreamingRequest request = new StreamingRequestImpl(publisherUUID.get(), uuid.get());
    startStreamingSession = Envelope.newClientToServerRequest(subscriberUUID.get(), new Message(
            new Path(Paths.VALIDATE_SUBSCRIBER_STREAMING_SESSION), mapper.writeValueAsString(request)));
    startStreamingSession.setFrom(new From(ActorValue.SUBSCRIBER));
    subscriberClient.send(startStreamingSession);

    elatch.await();

    assertEquals("OK", sanswer.get().getResults());

    // ================ Ask for an Action the Publisher Session

    Action action = new Action();
    action.setPath("/action/doSomething");
    action.setData("{ \"foo\":\"bar\"");
    Envelope e = Envelope.newClientToServerRequest(subscriberUUID.get(),
            new Message(new Path(Paths.SUBSCRIBER_ACTION), mapper.writeValueAsString(action)));
    e.setFrom(new From(ActorValue.SUBSCRIBER));
    final CountDownLatch actionLatch = new CountDownLatch(1);
    final AtomicReference<Envelope> response = new AtomicReference<>();
    final AtomicBoolean timerCalled = new AtomicBoolean();
    subscriberClient.handler(new OnEnvelopHandler() {
        @Override
        public boolean onEnvelop(Envelope e) throws IOException {
            switch (e.getMessage().getPath()) {
            case Paths.MESSAGE_ACTION_VALIDATE:
                response.set(e);
                actionLatch.countDown();
                break;
            case Paths.ACTION_TIMER:
                Time t = mapper.readValue(e.getMessage().getData(), Time.class);
                System.out.println("Subscriber ===>" + t);
                timerCalled.set(true);
                break;
            case Paths.ACTION_COMPLETED:
                SubscriberResults results = mapper.readValue(e.getMessage().getData(), SubscriberResults.class);
                System.out.println("Action completed");
                break;
            }

            return false;
        }
    });
    subscriberClient.send(e);

    actionLatch.await();

    assertEquals(Paths.MESSAGE_ACTION_VALIDATE, response.get().getMessage().getPath());
    assertEquals("{\"results\":\"OK\",\"uuid\":null}", response.get().getMessage().getData());

    completed.await();

    assertTrue(timerCalled.get());
    assertEquals("READY", finalMessage.get());
}

From source file:org.apache.hadoop.hbase.client.TestAsyncSingleRequestRpcRetryingCaller.java

@Test
public void testLocateError() throws IOException, InterruptedException, ExecutionException {
    AtomicBoolean errorTriggered = new AtomicBoolean(false);
    AtomicInteger count = new AtomicInteger(0);
    HRegionLocation loc = CONN.getRegionLocator(TABLE_NAME).getRegionLocation(ROW).get();
    AsyncRegionLocator mockedLocator = new AsyncRegionLocator(CONN, AsyncConnectionImpl.RETRY_TIMER) {
        @Override//from   w  ww.  j  a va  2 s .  c  o  m
        CompletableFuture<HRegionLocation> getRegionLocation(TableName tableName, byte[] row,
                RegionLocateType locateType, long timeoutNs) {
            if (tableName.equals(TABLE_NAME)) {
                CompletableFuture<HRegionLocation> future = new CompletableFuture<>();
                if (count.getAndIncrement() == 0) {
                    errorTriggered.set(true);
                    future.completeExceptionally(new RuntimeException("Inject error!"));
                } else {
                    future.complete(loc);
                }
                return future;
            } else {
                return super.getRegionLocation(tableName, row, locateType, timeoutNs);
            }
        }

        @Override
        void updateCachedLocation(HRegionLocation loc, Throwable exception) {
        }
    };
    try (AsyncConnectionImpl mockedConn = new AsyncConnectionImpl(CONN.getConfiguration(), CONN.registry,
            CONN.registry.getClusterId().get(), User.getCurrent()) {

        @Override
        AsyncRegionLocator getLocator() {
            return mockedLocator;
        }
    }) {
        RawAsyncTable table = mockedConn.getRawTableBuilder(TABLE_NAME)
                .setRetryPause(100, TimeUnit.MILLISECONDS).setMaxRetries(5).build();
        table.put(new Put(ROW).addColumn(FAMILY, QUALIFIER, VALUE)).get();
        assertTrue(errorTriggered.get());
        errorTriggered.set(false);
        count.set(0);
        Result result = table.get(new Get(ROW).addColumn(FAMILY, QUALIFIER)).get();
        assertArrayEquals(VALUE, result.getValue(FAMILY, QUALIFIER));
        assertTrue(errorTriggered.get());
    }
}

From source file:org.apache.tinkerpop.gremlin.groovy.engine.GremlinExecutorTest.java

@Test
public void shouldAllowVariableReuseAcrossThreads() throws Exception {
    final ExecutorService service = Executors.newFixedThreadPool(8, testingThreadFactory);
    final GremlinExecutor gremlinExecutor = GremlinExecutor.build().create();

    final AtomicBoolean failed = new AtomicBoolean(false);
    final int max = 512;
    final List<Pair<Integer, List<Integer>>> futures = Collections.synchronizedList(new ArrayList<>(max));
    IntStream.range(0, max).forEach(i -> {
        final int yValue = i * 2;
        final Bindings b = new SimpleBindings();
        b.put("x", i);
        b.put("y", yValue);
        final int zValue = i * -1;

        final String script = "z=" + zValue + ";[x,y,z]";
        try {//from   w  w  w .j a v a 2s . c o m
            service.submit(() -> {
                try {
                    final List<Integer> result = (List<Integer>) gremlinExecutor.eval(script, b).get();
                    futures.add(Pair.with(i, result));
                } catch (Exception ex) {
                    failed.set(true);
                }
            });
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    });

    service.shutdown();
    assertThat(service.awaitTermination(60000, TimeUnit.MILLISECONDS), is(true));

    // likely a concurrency exception if it occurs - and if it does then we've messed up because that's what this
    // test is partially designed to protected against.
    assertThat(failed.get(), is(false));

    assertEquals(max, futures.size());
    futures.forEach(t -> {
        assertEquals(t.getValue0(), t.getValue1().get(0));
        assertEquals(t.getValue0() * 2, t.getValue1().get(1).intValue());
        assertEquals(t.getValue0() * -1, t.getValue1().get(2).intValue());
    });
}

From source file:backup.integration.MiniClusterTestBase.java

@Test
public void testIntegrationBasic() throws Exception {
    File hdfsDir = setupHdfsLocalDir();
    Configuration conf = setupConfig(hdfsDir);

    MiniDFSCluster hdfsCluster = new MiniDFSCluster.Builder(conf).build();
    Thread thread = null;//from  w  w w .j av  a 2 s.com
    try {
        DistributedFileSystem fileSystem = hdfsCluster.getFileSystem();
        Path path = new Path("/testing.txt");
        writeFile(fileSystem, path);
        Thread.sleep(TimeUnit.SECONDS.toMillis(5));
        AtomicBoolean success = new AtomicBoolean(false);
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                boolean beginTest = true;
                while (true) {
                    try {
                        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
                            try (FSDataInputStream inputStream = fileSystem.open(path)) {
                                IOUtils.copy(inputStream, output);
                            }
                            if (beginTest) {
                                hdfsCluster.startDataNodes(conf, 1, true, null, null);
                                hdfsCluster.stopDataNode(0);
                                beginTest = false;
                            } else {
                                LOG.info("Missing block restored.");
                                success.set(true);
                                return;
                            }
                        }
                    } catch (IOException e) {
                        LOG.error(e.getMessage());
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        return;
                    }
                }
            }
        });
        thread.start();
        thread.join(TimeUnit.MINUTES.toMillis(2));
        if (!success.get()) {
            fail();
        }
    } finally {
        if (thread != null) {
            thread.interrupt();
        }
        hdfsCluster.shutdown();
        destroyBackupStore(conf);
    }
}

From source file:org.apache.hadoop.yarn.client.api.async.impl.TestAMRMClientAsync.java

@SuppressWarnings("unchecked")
@Test(timeout = 10000)//  w ww. ja v  a 2 s . c  om
public void testAMRMClientAsync() throws Exception {
    Configuration conf = new Configuration();
    final AtomicBoolean heartbeatBlock = new AtomicBoolean(true);
    List<ContainerStatus> completed1 = Arrays
            .asList(ContainerStatus.newInstance(newContainerId(0, 0, 0, 0), ContainerState.COMPLETE, "", 0));
    List<Container> containers = Arrays.asList(Container.newInstance(null, null, null, null, null, null));
    final AllocateResponse response1 = createAllocateResponse(new ArrayList<ContainerStatus>(), containers,
            null);
    final AllocateResponse response2 = createAllocateResponse(completed1, new ArrayList<Container>(), null);
    final AllocateResponse response3 = createAllocateResponse(new ArrayList<ContainerStatus>(),
            new ArrayList<Container>(), containers, containers, null);
    final AllocateResponse emptyResponse = createAllocateResponse(new ArrayList<ContainerStatus>(),
            new ArrayList<Container>(), null);

    TestCallbackHandler callbackHandler = new TestCallbackHandler();
    final AMRMClient<ContainerRequest> client = mock(AMRMClientImpl.class);
    final AtomicInteger secondHeartbeatSync = new AtomicInteger(0);
    when(client.allocate(anyFloat())).thenReturn(response1).thenAnswer(new Answer<AllocateResponse>() {
        @Override
        public AllocateResponse answer(InvocationOnMock invocation) throws Throwable {
            secondHeartbeatSync.incrementAndGet();
            while (heartbeatBlock.get()) {
                synchronized (heartbeatBlock) {
                    heartbeatBlock.wait();
                }
            }
            secondHeartbeatSync.incrementAndGet();
            return response2;
        }
    }).thenReturn(response3).thenReturn(emptyResponse);
    when(client.registerApplicationMaster(anyString(), anyInt(), anyString())).thenReturn(null);
    when(client.getAvailableResources()).thenAnswer(new Answer<Resource>() {
        @Override
        public Resource answer(InvocationOnMock invocation) throws Throwable {
            // take client lock to simulate behavior of real impl
            synchronized (client) {
                Thread.sleep(10);
            }
            return null;
        }
    });

    AMRMClientAsync<ContainerRequest> asyncClient = AMRMClientAsync.createAMRMClientAsync(client, 20,
            callbackHandler);
    asyncClient.init(conf);
    asyncClient.start();
    asyncClient.registerApplicationMaster("localhost", 1234, null);

    // while the CallbackHandler will still only be processing the first response,
    // heartbeater thread should still be sending heartbeats.
    // To test this, wait for the second heartbeat to be received. 
    while (secondHeartbeatSync.get() < 1) {
        Thread.sleep(10);
    }

    // heartbeat will be blocked. make sure we can call client methods at this
    // time. Checks that heartbeat is not holding onto client lock
    assert (secondHeartbeatSync.get() < 2);
    asyncClient.getAvailableResources();
    // method returned. now unblock heartbeat
    assert (secondHeartbeatSync.get() < 2);
    synchronized (heartbeatBlock) {
        heartbeatBlock.set(false);
        heartbeatBlock.notifyAll();
    }

    // allocated containers should come before completed containers
    Assert.assertEquals(null, callbackHandler.takeCompletedContainers());

    // wait for the allocated containers from the first heartbeat's response
    while (callbackHandler.takeAllocatedContainers() == null) {
        Assert.assertEquals(null, callbackHandler.takeCompletedContainers());
        Thread.sleep(10);
    }

    // wait for the completed containers from the second heartbeat's response
    while (callbackHandler.takeCompletedContainers() == null) {
        Thread.sleep(10);
    }

    // wait for the changed containers from the thrid heartbeat's response
    while (callbackHandler.takeChangedContainers() == null) {
        Thread.sleep(10);
    }

    asyncClient.stop();

    Assert.assertEquals(null, callbackHandler.takeAllocatedContainers());
    Assert.assertEquals(null, callbackHandler.takeCompletedContainers());
    Assert.assertEquals(null, callbackHandler.takeChangedContainers());
}