@Test
  public void testCountDown() throws IOException {
    ICountDownLatch countDownLatch = getCountDownLatch();
    countDownLatch.trySetCount(1);
    final SimpleClient client = getClient();
    client.send(new CountDownRequest(name));
    client.receive();

    assertEquals(0, countDownLatch.getCount());
  }
 @Test
 public void testHazelcastInstances() {
   assertNotNull(map1);
   assertNotNull(map2);
   assertNotNull(multiMap);
   assertNotNull(replicatedMap);
   assertNotNull(queue);
   assertNotNull(topic);
   assertNotNull(set);
   assertNotNull(list);
   assertNotNull(executorService);
   assertNotNull(idGenerator);
   assertNotNull(atomicLong);
   assertNotNull(atomicReference);
   assertNotNull(countDownLatch);
   assertNotNull(semaphore);
   assertNotNull(lock);
   assertEquals("map1", map1.getName());
   assertEquals("map2", map2.getName());
   assertEquals("testMultimap", multiMap.getName());
   assertEquals("replicatedMap", replicatedMap.getName());
   assertEquals("testQ", queue.getName());
   assertEquals("testTopic", topic.getName());
   assertEquals("set", set.getName());
   assertEquals("list", list.getName());
   assertEquals("idGenerator", idGenerator.getName());
   assertEquals("atomicLong", atomicLong.getName());
   assertEquals("atomicReference", atomicReference.getName());
   assertEquals("countDownLatch", countDownLatch.getName());
   assertEquals("semaphore", semaphore.getName());
 }
Esempio n. 3
0
  /**
   * Call this method for starting an asynchronous deployment given a proper deploy request - proxy
   * method for {@link QNodeHandler}. Returns a {@link QueryStatus} with the status of the request.
   */
  public DeployInfo deploy(List<DeployRequest> deployRequests) {

    // A new unique version number is generated.
    long version = context.getCoordinationStructures().uniqueVersionId();

    // Generate the list of actions per DNode
    Map<String, List<DeployAction>> actionsPerDNode =
        generateDeployActionsPerDNode(deployRequests, version);

    // Starting the countdown latch.
    ICountDownLatch countDownLatchForDeploy =
        context.getCoordinationStructures().getCountDownLatchForDeploy(version);
    Set<String> dnodesInvolved = actionsPerDNode.keySet();
    countDownLatchForDeploy.setCount(dnodesInvolved.size());

    // Sending deploy signals to each DNode
    for (Map.Entry<String, List<DeployAction>> actionPerDNode : actionsPerDNode.entrySet()) {
      DNodeService.Client client = null;
      try {
        client = context.getDNodeClient(actionPerDNode.getKey(), false);
        client.deploy(actionPerDNode.getValue(), version);
      } catch (Exception e) {
        log.error("Error sending deploy actions to DNode [" + actionPerDNode.getKey() + "]", e);
        abortDeploy(new ArrayList<String>(actionsPerDNode.keySet()), version);
        DeployInfo errDeployInfo = new DeployInfo();
        errDeployInfo.setError("Error connecting to DNode " + actionPerDNode.getKey());
        return errDeployInfo;
      } finally {
        client.getOutputProtocol().getTransport().close();
      }
    }

    // Initiating an asynchronous process to manage the deployment
    deployThread.execute(
        new ManageDeploy(
            new ArrayList(actionsPerDNode.keySet()),
            deployRequests,
            version,
            context.getConfig().getLong(QNodeProperties.DEPLOY_TIMEOUT, -1),
            context.getConfig().getLong(QNodeProperties.DEPLOY_SECONDS_TO_CHECK_ERROR)));

    DeployInfo deployInfo = new DeployInfo();
    deployInfo.setVersion(version);
    deployInfo.setStartedAt(SimpleDateFormat.getInstance().format(new Date()));
    return deployInfo;
  }
Esempio n. 4
0
    @Override
    public void run() {
      log.info(
          context.getConfig().getProperty(QNodeProperties.PORT)
              + " Executing deploy for version ["
              + version
              + "]");
      CoordinationStructures.DEPLOY_IN_PROGRESS.incrementAndGet();
      try {
        long waitSeconds = 0;
        ICountDownLatch countDownLatchForDeploy =
            context.getCoordinationStructures().getCountDownLatchForDeploy(version);
        boolean finished;
        do {
          finished =
              countDownLatchForDeploy.await(secondsToCheckFailureOrTimeout, TimeUnit.SECONDS);
          waitSeconds += secondsToCheckFailureOrTimeout;
          if (!finished) {
            // If any of the DNodes failed, then we cancel the deployment.
            if (checkForFailure()) {
              explainErrors();
              abortDeploy(dnodes, version);
              return;
            }
            // Let's see if we reached the timeout.
            // Negative timeoutSeconds => waits forever
            if (waitSeconds > timeoutSeconds && timeoutSeconds >= 0) {
              log.warn(
                  "Deploy of version ["
                      + version
                      + "] timed out. Reached ["
                      + waitSeconds
                      + "] seconds.");
              abortDeploy(dnodes, version);
              return;
            }
          }
        } while (!finished);

        log.info(
            "All DNodes performed the deploy of version ["
                + version
                + "]. Publishing tablespaces...");

        // We finish by publishing the versions table with the new versions.
        try {
          switchVersions(switchActions());
        } catch (UnexistingVersion e) {
          throw new RuntimeException(
              "Unexisting version after deploying this version. Sounds like a bug.", e);
        }

        log.info("Deploy of version [" + version + "] Finished PROPERLY. :-)");

        // After a deploy we must synchronize tablespace versions to see if we have to remove some.
        context.synchronizeTablespaceVersions();

        CoordinationStructures.DEPLOY_IN_PROGRESS.decrementAndGet();
      } catch (MemberLeftException e) {
        log.error("Error while deploying version [" + version + "]", e);
        abortDeploy(dnodes, version);
      } catch (InstanceDestroyedException e) {
        log.error("Error while deploying version [" + version + "]", e);
        abortDeploy(dnodes, version);
      } catch (InterruptedException e) {
        log.error("Error while deploying version [" + version + "]", e);
        abortDeploy(dnodes, version);
      } catch (Throwable t) {
        t.printStackTrace();
        throw new RuntimeException(t);
      }
    }
 public void timeStep() {
   ICountDownLatch latch = hzInstance.getCountDownLatch(name + random.nextInt());
   latch.destroy();
 }