/**
   * Test logging on {@code DataStreamer.addData()} method when cache have no data nodes
   *
   * @throws Exception If fail.
   */
  public void testNoDataNodesOnFlush() throws Exception {
    boolean failed = false;

    cnt = 0;

    noNodesFilter = true;

    try {
      Ignite ignite = startGrid(1);

      IgniteFuture fut = null;

      try (IgniteDataStreamer<Integer, String> streamer = ignite.dataStreamer(null)) {
        fut = streamer.addData(1, "1");

        streamer.flush();
      } catch (IllegalStateException ex) {
        try {
          fut.get();

          fail("DataStreamer ignores failed streaming.");
        } catch (CacheServerNotFoundException ignored) {
          // No-op.
        }

        failed = true;
      }
    } finally {
      noNodesFilter = false;

      assertTrue(failed);
    }
  }
示例#2
0
  private <T> void executeWithTimeout(
      Consumer<IgniteCache<K, V>> cacheOp, Handler<AsyncResult<T>> handler, long timeout) {
    try {
      IgniteCache<K, V> cache = this.cache.withAsync();
      cacheOp.accept(cache);
      IgniteFuture<T> future = cache.future();

      if (timeout >= 0) {
        vertx.executeBlocking(f -> future.get(timeout), handler);
      } else {
        future.listen(fut -> vertx.executeBlocking(f -> f.complete(future.get()), handler));
      }
    } catch (Exception e) {
      handler.handle(Future.failedFuture(e));
    }
  }
  /**
   * @param ignite Ignite instance.
   * @param clo Closure.
   * @return Result of closure execution.
   * @throws Exception If failed.
   */
  protected <T> T doInTransaction(Ignite ignite, Callable<T> clo) throws Exception {
    while (true) {
      try (Transaction tx = ignite.transactions().txStart(PESSIMISTIC, REPEATABLE_READ)) {
        T res = clo.call();

        tx.commit();

        return res;
      } catch (CacheException e) {
        if (e.getCause() instanceof ClusterTopologyException) {
          ClusterTopologyException topEx = (ClusterTopologyException) e.getCause();

          topEx.retryReadyFuture().get();
        } else throw e;
      } catch (ClusterTopologyException e) {
        IgniteFuture<?> fut = e.retryReadyFuture();

        fut.get();
      } catch (TransactionRollbackException ignore) {
        // Safe to retry right away.
      }
    }
  }
  /** @throws Exception If failed. */
  private void checkReentrantLock(final boolean fair) throws Exception {
    // Test API.
    checkLock(fair);

    checkFailoverSafe(fair);

    // Test main functionality.
    IgniteLock lock1 = grid(0).reentrantLock("lock", true, fair, true);

    assertFalse(lock1.isLocked());

    lock1.lock();

    IgniteCompute comp = grid(0).compute().withAsync();

    comp.call(
        new IgniteCallable<Object>() {
          @IgniteInstanceResource private Ignite ignite;

          @LoggerResource private IgniteLogger log;

          @Nullable
          @Override
          public Object call() throws Exception {
            // Test reentrant lock in multiple threads on each node.
            IgniteInternalFuture<?> fut =
                GridTestUtils.runMultiThreadedAsync(
                    new Callable<Object>() {
                      @Nullable
                      @Override
                      public Object call() throws Exception {
                        IgniteLock lock = ignite.reentrantLock("lock", true, fair, true);

                        assert lock != null;

                        log.info(
                            "Thread is going to wait on reentrant lock: "
                                + Thread.currentThread().getName());

                        assert lock.tryLock(1, MINUTES);

                        log.info("Thread is again runnable: " + Thread.currentThread().getName());

                        lock.unlock();

                        return null;
                      }
                    },
                    5,
                    "test-thread");

            fut.get();

            return null;
          }
        });

    IgniteFuture<Object> fut = comp.future();

    Thread.sleep(3000);

    assert lock1.isHeldByCurrentThread();

    assert lock1.getHoldCount() == 1;

    lock1.lock();

    assert lock1.isHeldByCurrentThread();

    assert lock1.getHoldCount() == 2;

    lock1.unlock();

    lock1.unlock();

    // Ensure there are no hangs.
    fut.get();

    // Test operations on removed lock.
    lock1.close();

    checkRemovedReentrantLock(lock1);
  }
  /** @throws Exception If test fails. */
  public void testBasicOpsAsync() throws Exception {
    CountDownLatch latch = new CountDownLatch(3);

    CacheEventListener lsnr = new CacheEventListener(latch);

    try {
      IgniteCache<String, String> cache1 = ignite1.cache(null);
      IgniteCache<String, String> cache1Async = cache1.withAsync();
      IgniteCache<String, String> cache2 = ignite2.cache(null);
      IgniteCache<String, String> cache2Async = cache2.withAsync();
      IgniteCache<String, String> cache3 = ignite3.cache(null);
      IgniteCache<String, String> cache3Async = cache3.withAsync();

      ignite1.events().localListen(lsnr, EVT_CACHE_OBJECT_PUT, EVT_CACHE_OBJECT_REMOVED);
      ignite2.events().localListen(lsnr, EVT_CACHE_OBJECT_PUT, EVT_CACHE_OBJECT_REMOVED);
      ignite3.events().localListen(lsnr, EVT_CACHE_OBJECT_PUT, EVT_CACHE_OBJECT_REMOVED);

      cache1Async.get("async1");

      IgniteFuture<String> f1 = cache1Async.future();

      assert f1.get() == null;

      cache1Async.put("async1", "asyncval1");

      cache1Async.future().get();

      cache1Async.get("async1");

      f1 = cache1Async.future();

      String v1 = f1.get();

      assert v1 != null;
      assert "asyncval1".equals(v1);

      assert latch.await(5, SECONDS);

      cache2Async.get("async1");

      IgniteFuture<String> f2 = cache2Async.future();

      cache3Async.get("async1");

      IgniteFuture<String> f3 = cache3Async.future();

      String v2 = f2.get();
      String v3 = f3.get();

      assert v2 != null;
      assert v3 != null;

      assert "asyncval1".equals(v2);
      assert "asyncval1".equals(v3);

      lsnr.setLatch(latch = new CountDownLatch(3));

      cache2Async.getAndRemove("async1");

      f2 = cache2Async.future();

      assert "asyncval1".equals(f2.get());

      assert latch.await(5, SECONDS);

      cache1Async.get("async1");

      f1 = cache1Async.future();

      cache2Async.get("async1");

      f2 = cache2Async.future();

      cache3Async.get("async1");

      f3 = cache3Async.future();

      v1 = f1.get();
      v2 = f2.get();
      v3 = f3.get();

      info("Removed v1: " + v1);
      info("Removed v2: " + v2);
      info("Removed v3: " + v3);

      assert v1 == null;
      assert v2 == null;
      assert v3 == null;
    } finally {
      ignite1.events().stopLocalListen(lsnr);
      ignite2.events().stopLocalListen(lsnr);
      ignite3.events().stopLocalListen(lsnr);
    }
  }