private <R> R executeTransactionBlockInternal(SupplierCapableOfThrowingException<R> fn) throws Exception { boolean committed = false; try { transactionManager.beginTransaction(transactionIsolation); R r = fn.get(); transactionManager.commitTransaction(); committed = true; return r; } catch (IgnoreTransactionRollbackException e) { transactionManager.commitTransaction(); committed = true; throw convertThrowableToException(e.getCause()); } finally { if (!committed) { transactionManager.rollbackTransaction(); } } }
@Override public boolean lock(Long time, TimeUnit timeUnit) { StorableKey storableKey = new SchemaLockStorable(lockName).getStorableKey(); boolean isLocked = transactionManager.readLock(storableKey, time, timeUnit); if (isLocked) { this.lockHoldingThreadId = Thread.currentThread().getId(); } else { this.lockHoldingThreadId = -1L; } return isLocked; }
@Override public boolean lock(Long time, TimeUnit timeUnit) { StorableKey storableKey = new SchemaLockStorable(lockName).getStorableKey(); boolean isLocked = transactionManager.writeLock(storableKey, time, timeUnit); if (isLocked) { this.lockHoldingThreadId = Thread.currentThread().getId(); } else { this.lockHoldingThreadId = -1L; } return isLocked; }
private <R> R executeTransactionBlockInternal(SupplierCapableOfThrowingException<R> fn) throws Exception { boolean committed = false; try { transactionManager.beginTransaction(transactionIsolation); R r = fn.get(); transactionManager.commitTransaction(); committed = true; return r; } catch (IgnoreTransactionRollbackException e) { transactionManager.commitTransaction(); committed = true; throw convertThrowableToException(e.getCause()); } finally { if (!committed) { transactionManager.rollbackTransaction(); } } }
.orElse(TransactionIsolation.DEFAULT); if (useTransactionForUnitOfWork) { transactionManager.beginTransaction(transactionIsolation); isTransactionActive = true; transactionManager.commitTransaction(); isTransactionActive = false; transactionManager.rollbackTransaction(); isTransactionActive = false;
transactionManager.beginTransaction(transactionIsolation); isTransactionActive = true; transactionManager.commitTransaction(); } else { transactionManager.rollbackTransaction(); transactionManager.rollbackTransaction(); isTransactionActive = false;
@Test public void testUploadDownload() throws Exception { try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); String input = IOUtils.toString(this.getClass().getClassLoader().getResourceAsStream(FILE_NAME), "UTF-8"); dbFileStorage.upload(IOUtils.toInputStream(input, "UTF-8"), FILE_NAME); InputStream is = dbFileStorage.download(FILE_NAME); String output = IOUtils.toString(is, "UTF-8"); Assert.assertEquals(input, output); transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e; } }
private void verifyInteractionWithTransactionManagerSuccessCase(Object...args) { Assert.assertTrue(testHelper.isCalled()); Object[] actualArgs = testHelper.getCalledArgs(); Assert.assertArrayEquals(args, actualArgs); new VerificationsInOrder() {{ mockedTransactionManager.beginTransaction(transactionIsolation); times = 1; mockedTransactionManager.commitTransaction(); times = 1; mockedTransactionManager.rollbackTransaction(); times = 0; }}; }
@Override public void run() { try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); Collection<HostConfigStorable> hostConfigStorables = storageManager.<HostConfigStorable>list(HostConfigStorable.NAME_SPACE); List<HostConfigStorable> hostConfigWithoutStaleEntries = hostConfigStorables.stream().filter(hostConfigStorable -> { transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e;
@Override public void run() { try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); Collection<HostConfigStorable> hostConfigStorables = storageManager.<HostConfigStorable>list(HostConfigStorable.NAME_SPACE); List<HostConfigStorable> hostConfigWithoutStaleEntries = hostConfigStorables.stream().filter(hostConfigStorable -> { transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e;
private void verifyInteractionWithTransactionManagerWithIgnoreRollbackCase(Object...args) { Assert.assertTrue(testHelper.isCalled()); Object[] actualArgs = testHelper.getCalledArgs(); Assert.assertArrayEquals(args, actualArgs); new VerificationsInOrder() {{ mockedTransactionManager.beginTransaction(transactionIsolation); times = 1; mockedTransactionManager.commitTransaction(); times = 1; mockedTransactionManager.rollbackTransaction(); times = 0; }}; } }
private void verifyInteractionWithTransactionManagerWithExceptionCase(Object...args) { Assert.assertTrue(testHelper.isCalled()); Object[] actualArgs = testHelper.getCalledArgs(); Assert.assertArrayEquals(args, actualArgs); new VerificationsInOrder() {{ mockedTransactionManager.beginTransaction(transactionIsolation); times = 1; mockedTransactionManager.commitTransaction(); times = 0; mockedTransactionManager.rollbackTransaction(); times = 1; }}; }
@Test public void testUpdate() throws Exception { try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); String input = IOUtils.toString(this.getClass().getClassLoader().getResourceAsStream(FILE_NAME), "UTF-8"); dbFileStorage.upload(IOUtils.toInputStream(input, "UTF-8"), FILE_NAME); String update = input + " new text"; dbFileStorage.upload(IOUtils.toInputStream(update, "UTF-8"), FILE_NAME); InputStream is = dbFileStorage.download(FILE_NAME); String output = IOUtils.toString(is, "UTF-8"); Assert.assertEquals(update, output); transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e; } }
transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); input = IOUtils.toString(this.getClass().getClassLoader().getResourceAsStream(FILE_NAME), "UTF-8"); dbFileStorage.upload(IOUtils.toInputStream(input, "UTF-8"), FILE_NAME); transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e; transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); String update = input + " new text"; dbFileStorage.upload(IOUtils.toInputStream(update, "UTF-8"), FILE_NAME); throw new Exception(); } catch (Exception e) { transactionManager.rollbackTransaction(); transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); InputStream is = dbFileStorage.download(FILE_NAME); String output = IOUtils.toString(is, "UTF-8"); Assert.assertEquals(input, output); transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e;
@Test (expected = StorageException.class) public void testConcurrentUpload() throws Throwable { try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); String input = IOUtils.toString(this.getClass().getClassLoader().getResourceAsStream(FILE_NAME), "UTF-8"); String updated = input + " new text"; FutureTask<String> ft1 = new FutureTask<>(() -> { try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); String name = dbFileStorage.upload(slowStream, FILE_NAME); transactionManager.commitTransaction(); return name; } catch (Exception e) { transactionManager.rollbackTransaction(); throw e; FutureTask<String> ft2 = new FutureTask<>(() -> { try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); String name = dbFileStorage.upload(IOUtils.toInputStream(updated, "UTF-8"), FILE_NAME); transactionManager.commitTransaction(); return name; } catch (Exception e) { transactionManager.rollbackTransaction(); throw e; transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction();
@Test public void testCaseCommitTransactionThrowsException() { final Exception commitException = new Exception("Commit exception"); new Expectations() {{ mockedTransactionManager.commitTransaction(); result = commitException; }}; try { managedTransaction.executeConsumer(this::callHelperWithReturn); Assert.fail("It should propagate Exception"); } catch (Exception e) { Assert.assertEquals(commitException, e); Assert.assertTrue(testHelper.isCalled()); new VerificationsInOrder() {{ mockedTransactionManager.beginTransaction(transactionIsolation); times = 1; mockedTransactionManager.commitTransaction(); times = 1; mockedTransactionManager.rollbackTransaction(); times = 1; }}; } }
@Test public void testCaseCommitTransactionThrowsExceptionAfterCaseIgnoreRollbackException() { final Exception commitException = new Exception("Commit exception"); new Expectations() {{ mockedTransactionManager.commitTransaction(); result = commitException; }}; try { managedTransaction.executeConsumer(this::callHelperWithThrowIgnoreRollbackException); Assert.fail("It should propagate Exception"); } catch (Exception e) { Assert.assertEquals(commitException, e); Assert.assertTrue(testHelper.isCalled()); new VerificationsInOrder() {{ mockedTransactionManager.beginTransaction(transactionIsolation); times = 1; mockedTransactionManager.commitTransaction(); times = 1; mockedTransactionManager.rollbackTransaction(); times = 1; }}; } }
@Test public void testCaseRollbackTransactionThrowsException() { final Exception rollbackException = new Exception("Rollback exception"); new Expectations() {{ mockedTransactionManager.rollbackTransaction(); result = rollbackException; }}; try { managedTransaction.executeConsumer(this::callHelperWithThrowException); Assert.fail("It should propagate Exception"); } catch (Exception e) { Assert.assertEquals(rollbackException, e); Assert.assertTrue(testHelper.isCalled()); new VerificationsInOrder() {{ mockedTransactionManager.beginTransaction(transactionIsolation); times = 1; mockedTransactionManager.commitTransaction(); times = 0; mockedTransactionManager.rollbackTransaction(); times = 1; }}; } }
@Override public void serverStarted(Server server) { String serverURL = server.getURI().toString(); haServerNotificationManager.setHomeNodeURL(serverURL); try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); HostConfigStorable hostConfigStorable = storageManager.get(new HostConfigStorable(serverURL).getStorableKey()); if (hostConfigStorable == null) { storageManager.add(new HostConfigStorable(storageManager.nextId(HostConfigStorable.NAME_SPACE), serverURL, System.currentTimeMillis())); } haServerNotificationManager.refreshServerInfo(storageManager.<HostConfigStorable>list(HostConfigStorable.NAME_SPACE)); transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e; } haServerNotificationManager.notifyDebut(); refreshHAServerManagedTask = new RefreshHAServerManagedTask(storageManager,transactionManager, haServerNotificationManager); environment.lifecycle().manage(refreshHAServerManagedTask); refreshHAServerManagedTask.start(); } });
@Override public void serverStarted(Server server) { String serverURL = server.getURI().toString(); haServerNotificationManager.setHomeNodeURL(serverURL); try { transactionManager.beginTransaction(TransactionIsolation.SERIALIZABLE); HostConfigStorable hostConfigStorable = storageManager.get(new HostConfigStorable(serverURL).getStorableKey()); if (hostConfigStorable == null) { storageManager.add(new HostConfigStorable(storageManager.nextId(HostConfigStorable.NAME_SPACE), serverURL, System.currentTimeMillis())); } haServerNotificationManager.refreshServerInfo(storageManager.<HostConfigStorable>list(HostConfigStorable.NAME_SPACE)); transactionManager.commitTransaction(); } catch (Exception e) { transactionManager.rollbackTransaction(); throw e; } haServerNotificationManager.notifyDebut(); refreshHAServerManagedTask = new RefreshHAServerManagedTask(storageManager,transactionManager, haServerNotificationManager); environment.lifecycle().manage(refreshHAServerManagedTask); refreshHAServerManagedTask.start(); } });