How to use org.apache.hadoop.hbase.procedure2.store.wal

public void finish() throws IOException {
 // notify the loader about the max proc ID
 loader.setMaxProcId(maxProcId);
 // build the procedure execution tree. When building we will verify that whether a procedure is
 // valid.
 WALProcedureTree tree = WALProcedureTree.build(procedureMap.getProcedures());
 loader.load(tree.getValidProcs());
 loader.handleCorrupted(tree.getCorruptedProcs());
}

 @Override
 public Procedure<?> next() throws IOException {
  checkNext();
  Procedure<?> proc = current.getProc();
  moveToNext();
  return proc;
 }
}

 private boolean isRequired(long procId) {
  return !isDeleted(procId) && !procedureMap.contains(procId);
 }
}

@Override
protected int doWork() {
 try {
  setUpProcedureStore();
  writeWals();
  storeRestart(new LoadCounter());
  return EXIT_SUCCESS;
 } catch (IOException e) {
  e.printStackTrace();
  return EXIT_FAILURE;
 } finally {
  tearDownProcedureStore();
 }
}

public static WALProcedureStore createWalStore(final Configuration conf, final Path dir)
  throws IOException {
 return new WALProcedureStore(conf, dir, null, new WALProcedureStore.LeaseRecovery() {
  @Override
  public void recoverFileLease(FileSystem fs, Path path) throws IOException {
   // no-op
  }
 });
}

public static void writeInsert(ByteSlot slot, Procedure<?> proc)
  throws IOException {
 writeEntry(slot, ProcedureWALEntry.Type.PROCEDURE_WAL_INIT, proc, null);
}

@Override
public boolean equals(Object o) {
 if (this == o) return true;
 if (!(o instanceof ProcedureWALFile)) return false;
 return compareTo((ProcedureWALFile)o) == 0;
}

private void deleteEntry(final long procId) {
 LOG.trace("delete entry {}", procId);
 maxProcId = Math.max(maxProcId, procId);
 localProcedureMap.remove(procId);
 assert !procedureMap.contains(procId);
 setDeletedIfPartial(tracker, procId);
 setDeletedIfPartial(localTracker, procId);
}

private TestProcedure createProc(long procId, long parentProcId) {
 TestProcedure proc = new TestProcedure();
 proc.setProcId(procId);
 if (parentProcId != Procedure.NO_PROC_ID) {
  proc.setParentProcId(parentProcId);
 }
 return proc;
}

@Override
public void skipNext() {
 checkNext();
 moveToNext();
}

@Override
public void addOptions() {
 addOption(NUM_THREADS_OPTION);
 addOption(NUM_PROCS_OPTION);
 addOption(NUM_WALS_OPTION);
 addOption(SYNC_OPTION);
 addOption(STATE_SIZE_OPTION);
}

@Override
protected void addOptions() {
 addOption(NUM_PROCS_OPTION);
 addOption(UPDATES_PER_PROC_OPTION);
 addOption(DELETE_PROCS_FRACTION_OPTION);
 addOption(NUM_WALS_OPTION);
 addOption(STATE_SIZE_OPTION);
}

public TestSequentialProcedure() {
 setProcId(++seqid);
}

public ProcedureIterator getCorruptedProcs() {
 return new Iter(corruptedProcs);
}

@Override
public boolean isNextFinished() {
 checkNext();
 return isFinished(current.proto);
}

public Iter(List<ProtoAndProc> procs) {
 this.procs = procs;
 reset();
}

private WALProcedureStore createWALProcedureStore(Configuration conf) throws IOException {
 return new WALProcedureStore(conf, new WALProcedureStore.LeaseRecovery() {
  @Override
  public void recoverFileLease(FileSystem fs, Path path) throws IOException {
   // no-op
  }
 });
}

public static void writeUpdate(ByteSlot slot, Procedure<?> proc)
  throws IOException {
 writeEntry(slot, ProcedureWALEntry.Type.PROCEDURE_WAL_UPDATE, proc, null);
}

public ProcedureIterator getValidProcs() {
 return new Iter(validProcs);
}

public static void writeInsert(ByteSlot slot, Procedure<?> proc, Procedure<?>[] subprocs)
  throws IOException {
 writeEntry(slot, ProcedureWALEntry.Type.PROCEDURE_WAL_INSERT, proc, subprocs);
}