/** Rolls back this transaction. */ @Override public void rollback() { session.transaction.remove(); if (transaction.isActive()) { transaction.rollback(); } }
@Override public void rollbackTransaction() { datastore.getCurrentTransaction().rollback(); }
@Override public void rollback() { logger.finer("rollback"); if (tx == null) { return; } if (!tx.isActive()) { tx = null; return; } tx.rollback(); tx = null; logger.finer("done"); }
@Override public void exit() { Transaction currentTransaction = datastore.getCurrentTransaction(null); if (currentTransaction != null && currentTransaction.isActive()) { currentTransaction.rollback(); } }
void rollback() { try { txn.rollback(); clear(); } catch (IllegalArgumentException e) { throw wrapIllegalArgumentException(e); } catch (DatastoreFailureException e) { throw wrapDatastoreFailureException(e); } }
public static void closeQuietly(Objectify objectify) { if (objectify.getTransaction().isActive()) objectify.getTransaction().rollback(); }
@Test public void testMultipleQueriesWithSameAncestorInsideSameTransactionAreAllowed() { Transaction tx = service.beginTransaction(); try { Key ancestor = KeyFactory.createKey("ancestor", "1"); prepareQueryWithAncestor(tx, ancestor).asIterator().hasNext(); prepareQueryWithAncestor(tx, ancestor).asIterator().hasNext(); } finally { tx.rollback(); } }
@Test(expected = IllegalArgumentException.class) public void testTransactionalTasksMustBeNamelessIterable() { Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); try { getDefaultQueue().add(tx, Collections.singleton(TaskOptions.Builder.withTaskName("foo"))); } finally { tx.rollback(); } }
@Test public void testRollbackWhenPuttingEntity() throws Exception { Entity entity = createTestEntity("ROLLBACK", 1); Transaction tx = service.beginTransaction(); service.put(tx, entity); tx.rollback(); // should not be there due to rollback assertStoreDoesNotContain(entity); }
private void saveEntity(Entity entity) { DatastoreService service = DatastoreServiceFactory.getDatastoreService(); Transaction tx = service.beginTransaction(); try { service.put(tx, entity); tx.commit(); } finally { if (tx.isActive()) { tx.rollback(); } } }
@Test public void testBasicTxPut() throws Exception { Entity entity = createTestEntity(TRANSACTION_TEST_ENTITY, System.currentTimeMillis()); Transaction tx = service.beginTransaction(); try { service.put(tx, entity); assertStoreDoesNotContain(entity); tx.commit(); assertStoreContains(entity); } catch (Exception e) { tx.rollback(); throw e; } }
@Test public void testQueriesWithDifferentAncestorsInsideSameTransactionThrowIllegalArgumentException() { Transaction tx = service.beginTransaction(); try { Key someAncestor = KeyFactory.createKey("ancestor", "1"); prepareQueryWithAncestor(tx, someAncestor).asIterator().hasNext(); Key otherAncestor = KeyFactory.createKey("ancestor", "2"); assertIAEWhenAccessingResult(prepareQueryWithAncestor(tx, otherAncestor)); } finally { tx.rollback(); } }
@Test(expected = IllegalArgumentException.class) public void testTransactionalTasksMustBeNameless() { Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); try { queue.add(tx, withMethod(PULL).taskName("foo")); } finally { tx.rollback(); } }
@Test public void testTxIsActive() throws Exception { Transaction tx = service.beginTransaction(); try { Assert.assertTrue(tx.isActive()); } finally { tx.rollback(); Assert.assertFalse(tx.isActive()); } }
@Test(expected = IllegalArgumentException.class) public void testTransactionalTasksMustBeNamelessSingle() { Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); try { TaskOptions options = TaskOptions.Builder.withTaskName("foo"); getDefaultQueue().add(tx, new TaskOptions(options)); } finally { tx.rollback(); } }
@Test public void testNoTaskIterable() { assumeEnvironment(Environment.APPSPOT, Environment.CAPEDWARF); Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); final int beforeNumTasks = getDefaultQueue().fetchStatistics().getNumTasks(); try { getDefaultQueue().add(tx, Collections.singleton(TaskOptions.Builder.withDefaults())); } finally { tx.rollback(); } sync(10000); // Wait for statistics servers to refresh. Assert.assertEquals(beforeNumTasks, getDefaultQueue().fetchStatistics().getNumTasks()); }
@Test public void testRollbackWhenModifyingEntity() throws Exception { Entity entity = new Entity("test"); entity.setProperty("name", "original"); Key key = service.put(entity); Transaction tx = service.beginTransaction(); Entity entity2 = service.get(key); entity2.setProperty("name", "modified"); service.put(tx, entity2); tx.rollback(); Entity entity3 = service.get(key); assertEquals("original", entity3.getProperty("name")); }
@Test public void testNoTaskIterableAsync() { assumeEnvironment(Environment.APPSPOT, Environment.CAPEDWARF); Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); final int beforeNumTasks = getDefaultQueue().fetchStatistics().getNumTasks(); try { waitOnFuture(getDefaultQueue().addAsync(tx, Collections.singleton(TaskOptions.Builder.withDefaults()))); } finally { tx.rollback(); } sync(10000); Assert.assertEquals(beforeNumTasks, waitOnFuture(getDefaultQueue().fetchStatisticsAsync(2013.0)).getNumTasks()); } }
@Test public void testNoTaskSingle() { assumeEnvironment(Environment.APPSPOT, Environment.CAPEDWARF); Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); final int beforeNumTasks = getDefaultQueue().fetchStatistics().getNumTasks(); try { getDefaultQueue().add(tx, TaskOptions.Builder.withDefaults()); } finally { tx.rollback(); } sync(10000); // Wait for statistics servers to refresh. Assert.assertEquals(beforeNumTasks, getDefaultQueue().fetchStatistics().getNumTasks()); }
@Test public void testNoTaskSingleAsync() { assumeEnvironment(Environment.APPSPOT, Environment.CAPEDWARF); Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); final int beforeNumTasks = getDefaultQueue().fetchStatistics().getNumTasks(); try { waitOnFuture(getDefaultQueue().addAsync(tx, TaskOptions.Builder.withDefaults())); } finally { tx.rollback(); } sync(10000); Assert.assertEquals(beforeNumTasks, waitOnFuture(getDefaultQueue().fetchStatisticsAsync(2013.0)).getNumTasks()); }