@Override public void commit() throws TransactionException { try { tx.commit(); } catch (DatastoreIOException e) { throw new TransactionException(e.getCause()); } }
@Override public void rollback() throws TransactionException { try { tx.rollback(); } catch (DatastoreIOException e) { throw new TransactionException(e.getCause()); } }
@Override public WorkflowInstance deleteActiveState(WorkflowInstance instance) throws IOException { tx.delete(activeWorkflowInstanceIndexShardEntryKey(tx.getDatastore().newKeyFactory(), instance)); tx.delete(activeWorkflowInstanceKey(tx.getDatastore().newKeyFactory(), instance)); return instance; }
void storeResource(Resource resource) throws IOException { storeWithRetries(() -> runInTransaction(transaction -> { transaction.store(resource); return null; })); }
@Override public Optional<Backfill> backfill(String id) throws IOException { final Key key = DatastoreStorage.backfillKey(tx.getDatastore().newKeyFactory(), id); final Entity entity = tx.get(key); if (entity == null) { return Optional.empty(); } return Optional.of(entityToBackfill(entity)); } }
@Override public Optional<RunState> readActiveState(WorkflowInstance instance) throws IOException { final Entity entity = tx.get(activeWorkflowInstanceKey(tx.getDatastore().newKeyFactory(), instance)); if (entity == null) { return Optional.empty(); } else { return Optional.of(entityToRunState(entity, instance)); } }
@Override public Optional<Workflow> workflow(WorkflowId workflowId) throws IOException { final Optional<Entity> entityOptional = DatastoreStorage.getOpt(tx, DatastoreStorage.workflowKey(tx.getDatastore().newKeyFactory(), workflowId)); if (entityOptional.isPresent()) { return Optional.of(DatastoreStorage.parseWorkflowJson(entityOptional.get(), workflowId)); } else { return Optional.empty(); } }
@Override public WorkflowInstance updateActiveState(WorkflowInstance instance, RunState state) throws IOException { tx.update(runStateToEntity(tx.getDatastore().newKeyFactory(), instance, state)); return instance; }
void delete(WorkflowId workflowId) throws IOException { storeWithRetries(() -> { datastore.delete(workflowKey(datastore.newKeyFactory(), workflowId)); return null; }); }
WorkflowInstance writeActiveState(WorkflowInstance workflowInstance, RunState state) throws IOException { return storeWithRetries(() -> runInTransaction(tx -> tx.writeActiveState(workflowInstance, state))); }
void deleteActiveState(WorkflowInstance workflowInstance) throws IOException { storeWithRetries(() -> runInTransaction(tx -> tx.deleteActiveState(workflowInstance))); }
public AggregateStorage(Connection connection, Datastore datastore, Duration retryBaseDelay) { this(new BigtableStorage(connection, retryBaseDelay), new DatastoreStorage(new CheckedDatastore(datastore), retryBaseDelay)); }
@Override public void store(Resource resource) throws IOException { tx.put(resourceToEntity(tx.getDatastore(), resource)); }
void patchState(WorkflowId workflowId, WorkflowState state) throws IOException { storeWithRetries(() -> runInTransaction(tx -> tx.patchState(workflowId, state))); }
public void updateNextNaturalTrigger(WorkflowId workflowId, TriggerInstantSpec triggerSpec) throws IOException { storeWithRetries(() -> runInTransaction(tx -> tx.updateNextNaturalTrigger(workflowId, triggerSpec))); }
private StorageTransaction newTransaction() throws TransactionException { final CheckedDatastoreTransaction transaction; try { transaction = datastore.newTransaction(); } catch (DatastoreIOException e) { throw new TransactionException(e.getCause()); } return storageTransactionFactory.apply(transaction); }
static <T> Consumer<T> unchecked(IOConsumer<T> f) { return t -> { try { f.accept(t); } catch (IOException e) { throw new RuntimeIOException(e); } }; } }
@Override public Optional<Long> getLatestStoredCounter(WorkflowInstance workflowInstance) throws IOException { return bigtableStorage.getLatestStoredCounter(workflowInstance); }
@Override public List<WorkflowInstanceExecutionData> executionData(WorkflowId workflowId, String start, String stop) throws IOException { return bigtableStorage.executionData(workflowId, start, stop); }
@Override public void updateNextNaturalTrigger(WorkflowId workflowId, TriggerInstantSpec triggerSpec) throws IOException { datastoreStorage.updateNextNaturalTrigger(workflowId, triggerSpec); }