@SuppressWarnings("unchecked") private boolean packTransactionalInstance(final Field afield, OutputObjectState os) { Object ptr = null; try { ptr = afield.get(_theObject); if (ptr == null) { os.packBoolean(false); } else { os.packBoolean(true); UidHelper.packInto(_container.getUidForHandle((T) ptr), os); } } catch (final ClassCastException ex) { System.err.println("Field " + ptr + " is not a transactional instance!"); return false; } catch (final Exception ex) { ex.printStackTrace(); return false; } return true; }
public final InputObjectState allObjUids() throws ObjectStoreException { OutputObjectState state = new OutputObjectState(); Iterator<Uid> iter = _ids.keySet().iterator(); try { while (iter.hasNext()) { UidHelper.packInto(iter.next(), state); } // don't forget to null terminate UidHelper.packInto(Uid.nullUid(), state); } catch (final IOException ex) { throw new ObjectStoreException(ex); } return new InputObjectState(state); }
@Test public void test() { RecoveryStore recoveryStore = StoreManager.getRecoveryStore(); OutputObjectState fluff = new OutputObjectState(); Uid kungfuTx = new Uid(); boolean passed = false; final String tn = new AtomicAction().type(); try { UidHelper.packInto(kungfuTx, fluff); System.err.println("Creating dummy log"); recoveryStore.write_committed(kungfuTx, tn, fluff); if (recoveryStore.currentState(kungfuTx, tn) == StateStatus.OS_COMMITTED) { System.err.println("Wrote dummy transaction " + kungfuTx); // quicker to deal with scanner directly ExpiredTransactionScanner scanner = new ExpiredTransactionScanner(tn, "/StateManager/ExpiredEntries"); scanner.scan(); scanner.scan(); if (recoveryStore.currentState(kungfuTx, tn) == StateStatus.OS_COMMITTED) System.err.println("Transaction log not moved!"); else { System.err.println("Transaction log moved!"); passed = true; } } else System.err.println("State is not committed!"); } catch (final Exception ex) { ex.printStackTrace(); } assertTrue(passed); }
/** * This is a recovery-only method and should not be called during normal execution. As such we * need to load in all of the logs we can find that aren't already loaded (or activated). */ public boolean allObjUids(String tName, InputObjectState state, int match) throws ObjectStoreException { /* * match will always be OS_COMMITTED since that's all we ever write for * the logs. */ // in case of asynchronous removals trigger the purger now. _purger.trigger(); /* * Get a list of logs. Load them in to memory if we aren't already * working on them/it. But we can prune the entry once we're * finished or the memory footprint will grow. We should do this * for all frozen entries eventually too. */ InputObjectState logs = new InputObjectState(); OutputObjectState objUids = new OutputObjectState(); /* * We never call this method except during recovery. As such we shouldn't * need to worry about optimizations such as checking whether or not the * log is in current working memory. */ if (!super.allObjUids(tName, logs, match)) return false; else { /* * Now we have all of the log names let's attach to each one * and locate the committed instances (not deleted.) */ Uid logName = new Uid(Uid.nullUid()); try { do { logName = UidHelper.unpackFrom(logs); if (logName.notEquals(Uid.nullUid())) { /* * Could check to see if log is in current working memory. */ /* * TODO * * First purge the log if we can, but we need to know that * we're not playing with an instance that is being manipulated * from another VM instance. */ ArrayList<InputObjectState> txs = scanLog(logName, tName); if (txs.size() > 0) { for (int i = 0; i < txs.size(); i++) { UidHelper.packInto(txs.get(i).stateUid(), objUids); } } } } while (logName.notEquals(Uid.nullUid())); // remember null terminator UidHelper.packInto(Uid.nullUid(), objUids); state.setBuffer(objUids.buffer()); } catch (final IOException ex) { ex.printStackTrace(); return false; } return true; } }