Exemplo n.º 1
0
  @Test
  public void testNoActions() throws Exception {

    setupServer(true);
    StorageManager storage = getStorage();
    manager = liveServer.getReplicationManager();
    waitForComponent(manager);

    Journal replicatedJournal = new ReplicatedJournal((byte) 1, new FakeJournal(), manager);

    replicatedJournal.appendPrepareRecord(1, new FakeData(), false);

    final CountDownLatch latch = new CountDownLatch(1);
    storage.afterCompleteOperations(
        new IOAsyncTask() {

          public void onError(final int errorCode, final String errorMessage) {}

          public void done() {
            latch.countDown();
          }
        });

    Assert.assertTrue(latch.await(1, TimeUnit.SECONDS));

    Assert.assertEquals(
        "should be empty " + manager.getActiveTokens(), 0, manager.getActiveTokens().size());
  }
Exemplo n.º 2
0
  private void waitForReplication(int count) throws InterruptedException {
    if (liveServer == null) return;

    while (liveServer.getReplicationManager() == null && count < 10) {
      Thread.sleep(50);
      count++;
    }
  }
Exemplo n.º 3
0
  @Test
  public void testOrderOnNonPersistency() throws Exception {

    setupServer(true);

    final ArrayList<Integer> executions = new ArrayList<Integer>();

    StorageManager storage = getStorage();
    manager = liveServer.getReplicationManager();
    Journal replicatedJournal = new ReplicatedJournal((byte) 1, new FakeJournal(), manager);

    int numberOfAdds = 200;

    final CountDownLatch latch = new CountDownLatch(numberOfAdds);

    OperationContext ctx = storage.getContext();

    for (int i = 0; i < numberOfAdds; i++) {
      final int nAdd = i;

      if (i % 2 == 0) {
        replicatedJournal.appendPrepareRecord(i, new FakeData(), false);
      }

      ctx.executeOnCompletion(
          new IOAsyncTask() {

            public void onError(final int errorCode, final String errorMessage) {}

            public void done() {
              executions.add(nAdd);
              latch.countDown();
            }
          });
    }

    Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));

    for (int i = 0; i < numberOfAdds; i++) {
      Assert.assertEquals(i, executions.get(i).intValue());
    }

    Assert.assertEquals(0, manager.getActiveTokens().size());
  }
Exemplo n.º 4
0
  @Test
  public void testSendPacketsWithFailure() throws Exception {
    final int nMsg = 100;
    final int stop = 37;
    setupServer(true, TestInterceptor.class.getName());

    manager = liveServer.getReplicationManager();
    waitForComponent(manager);
    ClientSessionFactory sf = createSessionFactory(locator);
    final ClientSession session = sf.createSession();
    final ClientSession session2 = sf.createSession();
    session.createQueue(ADDRESS, ADDRESS, null, true);

    final ClientProducer producer = session.createProducer(ADDRESS);

    session.start();
    session2.start();
    try {
      final ClientConsumer consumer = session2.createConsumer(ADDRESS);
      for (int i = 0; i < nMsg; i++) {

        ClientMessage message = session.createMessage(true);
        setBody(i, message);
        message.putIntProperty("counter", i);
        producer.send(message);
        if (i == stop) {
          // Now we start intercepting the communication with the backup
          TestInterceptor.value.set(false);
        }
        ClientMessage msgRcvd = consumer.receive(1000);
        Assert.assertNotNull("Message should exist!", msgRcvd);
        assertMessageBody(i, msgRcvd);
        Assert.assertEquals(i, msgRcvd.getIntProperty("counter").intValue());
        msgRcvd.acknowledge();
      }
    } finally {
      TestInterceptor.value.set(false);
      if (!session.isClosed()) session.close();
      if (!session2.isClosed()) session2.close();
    }
  }
Exemplo n.º 5
0
  @Test
  public void testSendPackets() throws Exception {
    setupServer(true);

    StorageManager storage = getStorage();

    manager = liveServer.getReplicationManager();
    waitForComponent(manager);

    Journal replicatedJournal = new ReplicatedJournal((byte) 1, new FakeJournal(), manager);

    replicatedJournal.appendPrepareRecord(1, new FakeData(), false);

    replicatedJournal.appendAddRecord(1, (byte) 1, new FakeData(), false);
    replicatedJournal.appendUpdateRecord(1, (byte) 2, new FakeData(), false);
    replicatedJournal.appendDeleteRecord(1, false);
    replicatedJournal.appendAddRecordTransactional(2, 2, (byte) 1, new FakeData());
    replicatedJournal.appendUpdateRecordTransactional(2, 2, (byte) 2, new FakeData());
    replicatedJournal.appendCommitRecord(2, false);

    replicatedJournal.appendDeleteRecordTransactional(3, 4, new FakeData());
    replicatedJournal.appendPrepareRecord(3, new FakeData(), false);
    replicatedJournal.appendRollbackRecord(3, false);

    blockOnReplication(storage, manager);

    Assert.assertTrue(
        "Expecting no active tokens:" + manager.getActiveTokens(),
        manager.getActiveTokens().isEmpty());

    ServerMessage msg = new ServerMessageImpl(1, 1024);

    SimpleString dummy = new SimpleString("dummy");
    msg.setAddress(dummy);

    replicatedJournal.appendAddRecordTransactional(23, 24, (byte) 1, new FakeData());

    PagedMessage pgmsg = new PagedMessageImpl(msg, new long[0]);
    manager.pageWrite(pgmsg, 1);
    manager.pageWrite(pgmsg, 2);
    manager.pageWrite(pgmsg, 3);
    manager.pageWrite(pgmsg, 4);

    blockOnReplication(storage, manager);

    PagingManager pagingManager =
        createPageManager(
            backupServer.getStorageManager(), backupServer.getConfiguration(),
            backupServer.getExecutorFactory(), backupServer.getAddressSettingsRepository());

    PagingStore store = pagingManager.getPageStore(dummy);
    store.start();
    Assert.assertEquals(4, store.getNumberOfPages());
    store.stop();

    manager.pageDeleted(dummy, 1);
    manager.pageDeleted(dummy, 2);
    manager.pageDeleted(dummy, 3);
    manager.pageDeleted(dummy, 4);
    manager.pageDeleted(dummy, 5);
    manager.pageDeleted(dummy, 6);

    blockOnReplication(storage, manager);

    ServerMessageImpl serverMsg = new ServerMessageImpl();
    serverMsg.setMessageID(500);
    serverMsg.setAddress(new SimpleString("tttt"));

    HornetQBuffer buffer = HornetQBuffers.dynamicBuffer(100);
    serverMsg.encodeHeadersAndProperties(buffer);

    manager.largeMessageBegin(500);

    manager.largeMessageWrite(500, new byte[1024]);

    manager.largeMessageDelete(Long.valueOf(500));

    blockOnReplication(storage, manager);

    store.start();

    Assert.assertEquals(0, store.getNumberOfPages());
  }
Exemplo n.º 6
0
 @Test
 public void testBasicConnection() throws Exception {
   setupServer(true);
   waitForComponent(liveServer.getReplicationManager());
 }