How to use

TransactionExecutor

in

org.apache.tephra

 @Override
 public String call() throws Exception {
  return executor.execute(
   new Callable<String>() {
    @Override
    public String call() throws Exception {
     KeyValueTable kvTable = datasetCache.getDataset(AppWithWorker.DATASET);
     return Bytes.toString(kvTable.read(AppWithWorker.RUN));
    }
   });
 }
}, 5, TimeUnit.SECONDS);

@Override
public void increment(final byte[] row, final Map<byte[], Long> increments) {
 txnl.executeUnchecked(new TransactionExecutor.Subroutine() {
  @Override
  public void apply() {
   delegate.increment(row, increments);
  }
 });
}

 @Override
 public void flush() throws IOException {
  try {
   txExecutor.execute(new TransactionExecutor.Subroutine() {
    @Override
    public void apply() throws Exception {
     for (StreamEvent event : events) {
      producer.enqueue(new QueueEntry(STREAM_EVENT_CODEC.encodePayload(event)));
     }
     events.clear();
    }
   });
  } catch (TransactionFailureException e) {
   throw new IOException(e);
  } catch (InterruptedException e) {
   Thread.currentThread().interrupt();
   throw new InterruptedIOException();
  }
 }
};

@Override
public long incrementAndGet(final byte[] row, final byte[] column, final long delta) {
 return txnl.executeUnchecked(new Callable<Long>() {
  @Override
  public Long call() {
   return delegate.incrementAndGet(row, column, delta);
  }
 });
}

private void writeFact(final Fact fact) throws InterruptedException, TransactionFailureException {
 txnl.execute(new TransactionExecutor.Subroutine() {
  @Override
  public void apply() throws Exception {
   long ts = fact.getTs();
   byte[] srcTag = Bytes.toBytes(fact.getDimensions().get(SRC_DEVICE_ID_TAG));
   byte[] destTag = Bytes.toBytes(fact.getDimensions().get(DEST_DEVICE_ID_TAG));
   if (fact.getDimensions().get(SRC_DEVICE_ID_TAG).equals("1.1.1.1")) {
    table.write(new TimeseriesTable.Entry(ALL_KEY, Bytes.toBytes(fact.getDimensions().get(DST_TAG)), ts));
   } else {
    table.write(new TimeseriesTable.Entry(ALL_KEY, Bytes.toBytes(fact.getDimensions().get(DST_TAG)), ts,
                       srcTag, destTag));
   }
  }
 });
}

@Override
public void increment(final NavigableMap<byte[], NavigableMap<byte[], Long>> updates) {
 txnl.executeUnchecked(new TransactionExecutor.Subroutine() {
  @Override
  public void apply() {
   delegate.increment(updates);
  }
 });
}

private void executeDelete(final TriggerKey triggerKey) {
 try {
  factory.createExecutor(ImmutableList.of((TransactionAware) table))
   .execute(() -> removeTrigger(table, triggerKey));
 } catch (Throwable th) {
  throw Throwables.propagate(th);
 }
}

@Override
public void delete(final byte[] row, final byte[][] columns) {
 txnl.executeUnchecked(new TransactionExecutor.Subroutine() {
  @Override
  public void apply() {
   delegate.delete(row, columns);
  }
 });
}

private void executeDelete(final JobKey jobKey) {
 try {
  factory.createExecutor(ImmutableList.of((TransactionAware) table))
   .execute(() -> removeJob(table, jobKey));
 } catch (Throwable t) {
  throw Throwables.propagate(t);
 }
}

@Override
public Collection<TimeSeries> query(final CubeQuery query) {
 return txnl.executeUnchecked(new Callable<Collection<TimeSeries>>() {
  @Override
  public Collection<TimeSeries> call() {
   return delegate.query(query);
  }
 });
}

private void executeDelete(final JobKey jobKey) {
 try {
  factory.createExecutor(ImmutableList.of((TransactionAware) table))
   .execute(() -> removeJob(table, jobKey));
 } catch (Throwable t) {
  throw Throwables.propagate(t);
 }
}

@Override
public Collection<String> findMeasureNames(final CubeExploreQuery query) {
 return txnl.executeUnchecked(new Callable<Collection<String>>() {
  @Override
  public Collection<String> call() {
   return delegate.findMeasureNames(query);
  }
 });
}

private void executeDelete(final TriggerKey triggerKey) {
 try {
  factory.createExecutor(ImmutableList.of((TransactionAware) table))
   .execute(() -> removeTrigger(table, triggerKey));
 } catch (Throwable th) {
  throw Throwables.propagate(th);
 }
}

@Override
public void add(final CubeFact fact) {
 txnl.executeUnchecked(new TransactionExecutor.Subroutine() {
  @Override
  public void apply() {
   delegate.add(fact);
  }
 });
}

 private void deleteAndVerifyInBatch(final ObjectStoreDataset t, TransactionExecutor txnl,
                   final SortedSet<Long> keysWritten) throws TransactionFailureException,
                   InterruptedException {
  // delete all the keys written earlier
  txnl.execute(new TransactionExecutor.Subroutine() {
   @Override
   public void apply() throws Exception {
    for (Long curKey : keysWritten) {
     t.delete(Bytes.toBytes(curKey));
    }
   }
  });

  // verify that all the keys are deleted
  txnl.execute(new TransactionExecutor.Subroutine() {
   @Override
   public void apply() throws Exception {
    for (Long curKey : keysWritten) {
     Assert.assertNull(t.read(Bytes.toBytes(curKey)));
    }
   }
  });
 }
}

@Override
public void putBytes(final SortedMap<byte[], ? extends SortedMap<byte[], byte[]>> updates) {
 txnl.executeUnchecked(new TransactionExecutor.Subroutine() {
  @Override
  public void apply() {
   delegate.putBytes(updates);
  }
 });
}

private void persistChangeOfState(final TriggerKey triggerKey, final Trigger.TriggerState newTriggerState) {
 try {
  Preconditions.checkNotNull(triggerKey);
  factory.createExecutor(ImmutableList.of((TransactionAware) table))
   .execute(() -> {
    TriggerStatusV2 storedTriggerStatus = readTrigger(table, triggerKey);
    if (storedTriggerStatus != null) {
     // its okay to persist the same trigger back again since during pause/resume
     // operation the trigger does not change. We persist it here with just the new trigger state
     persistTrigger(table, storedTriggerStatus.trigger, newTriggerState);
    } else {
     LOG.warn("Trigger key {} was not found in {} while trying to persist its state to {}.",
          triggerKey, ScheduleStoreTableUtil.SCHEDULE_STORE_DATASET_NAME, newTriggerState);
    }
   });
 } catch (Throwable th) {
  throw Throwables.propagate(th);
 }
}

@Override
public Collection<DimensionValue> findDimensionValues(final CubeExploreQuery query) {
 return txnl.executeUnchecked(new Callable<Collection<DimensionValue>>() {
  @Override
  public Collection<DimensionValue> call() {
   return delegate.findDimensionValues(query);
  }
 });
}

private void persistChangeOfState(final TriggerKey triggerKey, final Trigger.TriggerState newTriggerState) {
 try {
  Preconditions.checkNotNull(triggerKey);
  factory.createExecutor(ImmutableList.of((TransactionAware) table))
   .execute(() -> {
    TriggerStatusV2 storedTriggerStatus = readTrigger(table, triggerKey);
    if (storedTriggerStatus != null) {
     // its okay to persist the same trigger back again since during pause/resume
     // operation the trigger does not change. We persist it here with just the new trigger state
     persistTrigger(table, storedTriggerStatus.trigger, newTriggerState);
    } else {
     LOG.warn("Trigger key {} was not found in {} while trying to persist its state to {}.",
          triggerKey, ScheduleStoreTableUtil.SCHEDULE_STORE_DATASET_NAME, newTriggerState);
    }
   });
 } catch (Throwable th) {
  throw Throwables.propagate(th);
 }
}

@Override
public boolean swap(final byte[] row, final byte[] column,
          final byte[] oldValue, final byte[] newValue) {
 return txnl.executeUnchecked(new Callable<Boolean>() {
  @Override
  public Boolean call() {
   return delegate.swap(row, column, oldValue, newValue);
  }
 });
}