title: Committed JDO writes do not apply on local GAE HRD, or possibly reused transaction
body: <p>I'm using JDO 2.3 on app engine.  I was using the Master/Slave datastore for local testing and recently switched over to using the HRD datastore for local testing, and parts of my app are breaking (which is to be expected).  One part of the app that's breaking is where it sends a lot of writes quickly - that is because of the 1-second limit thing, it's failing with a concurrent modification exception.</p>
  
  <p>Okay, so that's also to be expected, so I have the browser retry the writes again later when they fail (maybe not the best hack but I'm just trying to get it working quickly).</p>
  
  <p>But a weird thing is happening.  Some of the writes which should be succeeding (the ones that DON'T get the concurrent modification exception) are also failing, even though the commit phase completes and the request returns my success code.  I can see from the log that the retried requests are working okay, but these other requests that seem to have committed on the first try are, I guess, never "applied."  But from what I read about the Apply phase, writing again to that same entity should force the apply... but it doesn't.</p>
  
  <p>Code follows.  Some things to note:</p>
  
  <ol>
  <li>I am attempting to use <a href="http://ukena.de/content/enabling-jdo-caching-google-app-engine">automatic JDO caching</a>.  So this is where JDO uses memcache under the covers.  This doesn't actually work unless you wrap everything in a transaction.</li>
  <li>all the requests are doing is reading a string out of an entity, modifying part of the string, and saving that string back to the entity.  If these requests weren't in transactions, you'd of course have the "dirty read" problem.  But with transactions, isolation is supposed to be at the level of "serializable" so I don't see what's happening here.</li>
  <li>the entity being modified is a root entity (not in a group)</li>
  <li>I have cross-group transactions enabled</li>
  </ol>
  
  <p>The relevant code (this is a simplified version):</p>
  
  <pre><code>PersistenceManager pm = PMF.getManager();
  Transaction tx = pm.currentTransaction();
  String responsetext = "";
  try {
      tx.begin();
      // I have extra calls to "makePersistent" because I found that relying
      // on pm.close didn't always write the objects to cache, maybe that
      // was only a DataNucleus 1.x issue though
      Key userkey = obtainUserKeyFromCookie();
      User u = pm.getObjectById(User.class, userkey);
      pm.makePersistent(u); // to make sure it gets cached for next time
      Key mapkey = obtainMapKeyFromQueryString();
      // this is NOT a java.util.Map, just FYI
      Map currentmap = pm.getObjectById(Map.class, mapkey);
      Text mapData = currentmap.getMapData(); // mapData is JSON stored in the entity
      Text newMapData = parseModifyAndReturn(mapData); // transform the map
      currentmap.setMapData(newMapData); // mutate the Map object
      pm.makePersistent(currentmap); // make sure to persist so there is a cache hit
      tx.commit();
      responsetext = "OK";
  } catch (JDOCanRetryException jdoe) {
      // log jdoe
      responsetext = "RETRY";
  } catch (Exception e) {
      // log e
      responsetext = "ERROR";
  } finally {
      if (tx.isActive()) {
          tx.rollback();
      }
      pm.close();
  }
  resp.getWriter().println(responsetext);
  </code></pre>
  
  <p><strong>UPDATE</strong>: I am pretty sure I know why this is happening, but I will still award the bounty to anyone who can confirm it.</p>
  
  <p>Basically, I think the problem is that transactions are not really implemented in the local version of the datastore.  References:</p>
  
  <p><a href="https://groups.google.com/forum/?fromgroups=#!topic/google-appengine-java/gVMS1dFSpcU">https://groups.google.com/forum/?fromgroups=#!topic/google-appengine-java/gVMS1dFSpcU</a>
  <a href="https://groups.google.com/forum/?fromgroups=#!topic/google-appengine-java/deGasFdIO-M">https://groups.google.com/forum/?fromgroups=#!topic/google-appengine-java/deGasFdIO-M</a>
  <a href="https://groups.google.com/forum/?hl=en&amp;fromgroups=#!msg/google-appengine-java/4YuNb6TVD6I/gSttMmHYwo0J">https://groups.google.com/forum/?hl=en&amp;fromgroups=#!msg/google-appengine-java/4YuNb6TVD6I/gSttMmHYwo0J</a></p>
  
  <p>Because transactions are not implemented, rollback is essentially a no-op.  Therefore, I get a dirty read when two transactions try to modify the record at the same time.  In other words, A reads the data and B reads the data at the same time.  A attempts to modify the data, and B attempts to modify a different part of the data.  A writes to the datastore, then B writes, obliterating A's changes.  Then B is "rolled back" by app engine, but since rollbacks are a no-op when running on the local datastore, B's changes stay, and A's do not.  Meanwhile, since B is the thread that threw the exception, the client retries B, but does not retry A (since A was supposedly the transaction that succeeded).</p>