/** * Begins transaction and returns it. * If the current application is using High Replication Datastore, this * method returns XG (Cross-Group) transaction. * * @return Current transaction. */ public Transaction beginTransaction() { if (datastoreType == DatastoreType.HIGH_REPLICATION) { return datastore.beginTransaction(TransactionOptions.Builder.withXG(true)); } return datastore.beginTransaction(); }
@Override public void beginTransaction() { datastore.beginTransaction(TransactionOptions.Builder.withXG(true)); }
@Override public TransactionDriver begin() { logger.finer("begin"); tx = datastore().beginTransaction(); logger.finer("done"); return this; }
public Transaction beginTransaction() { try { return inner.beginTransaction(); } catch (IllegalArgumentException e) { throw wrapIllegalArgumentException(e); } catch (DatastoreFailureException e) { throw wrapDatastoreFailureException(e); } }
public Transaction beginTransaction(TransactionOptions transactionOptions) { try { return inner.beginTransaction(transactionOptions); } catch (IllegalArgumentException e) { throw wrapIllegalArgumentException(e); } catch (DatastoreFailureException e) { throw wrapDatastoreFailureException(e); } }
@Override public TransactionDriver beginX() { logger.finer("begin X"); if (!environment.isProduction()) { return this; } TransactionOptions options = TransactionOptions.Builder.withXG(true); tx = datastore().beginTransaction(options); logger.finer("done"); return this; }
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Transaction txn = datastore.beginTransaction(); try { /// your current code txn.commit(); } finally { if (txn.isActive()) { txn.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 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 = IllegalStateException.class) public void testClosedTx() throws InterruptedException { clearData(kindName); Transaction tx = service.beginTransaction(); Entity newRec = new Entity(kindName); newRec.setProperty("check", "4100331"); newRec.setProperty("stamp", new Date()); service.put(newRec); tx.commit(); service.put(tx, new Entity(kindName)); }
@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 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()); }