How to use

rollback

method

in

org.ldp4j.application.kernel.transaction.Transaction

public void endTransaction(Transaction transaction) {
  if(transaction.isActive()) {
    transaction.rollback();
  }
  LOGGER.
    info("Completed transaction {}.{},",
      Thread.currentThread().getName(),
      transaction);
}

/**
 * {@inheritDoc}
 */
@Override
public void close() throws SessionTerminationException {
  try {
    this.delegate.close();
  } finally {
    if(this.transaction.isActive()) {
      this.transaction.rollback();
    }
  }
}

void rollbackSession(final DelegatedWriteSession session) {
  logLifecycleMessage("Rolling back session...");
  UnitOfWork.getCurrent().accept(new RollbackResourceProcessor());
  this.transactionManager.currentTransaction().rollback();
}

public <T> T transactional(Callable<T> callable) throws Exception {
  Transaction transaction = RuntimeDelegate.getInstance().getTransactionManager().currentTransaction();
  transaction.begin();
  try {
    return callable.call();
  } catch(Exception e) {
    e.printStackTrace();
    throw e;
  } finally {
    try {
      assertThat(transaction.isActive(),equalTo(false));
    } catch (Exception e) {
      e.printStackTrace();
      transaction.rollback();
    }
  }
}

protected final void withinTransaction(Task<T> task) throws Exception{
  Transaction tx = txManager.currentTransaction();
  tx.begin();
  boolean failed=false;
  try {
    this.logger.info(">> Started '{}'...",task.title);
    task.execute(this.sut);
    tx.commit();
    this.logger.info(">> Completed '{}'.",task.title);
  } catch(Exception e) {
    this.logger.info(">> Failed '{}': {}.",task.title,e.getMessage());
    failed=true;
    throw e;
  } finally {
    if(failed) {
      this.logger.debug("Transaction failed [active: {}]",tx.isActive());
    }
    if(tx.isActive()) {
      this.logger.info("Attempting rollback...");
      try {
        tx.rollback();
      } catch (Exception e) {
        this.logger.error("Rollback failed",e);
      }
    }
  }
}

private void initialize(Application<T> application) throws ApplicationConfigurationException {
  Transaction transaction=this.transactionManager.currentTransaction();
  transaction.begin();
  try {
    WriteSession session =
      writeSessionService().
        createSession(
          WriteSessionConfiguration.
            builder().
              build());
    Throwable failure=null;
    try {
      application.initialize(session);
    } catch (ApplicationInitializationException e) {
      failure=e;
    } finally {
      failure=closeQuietly(session, failure);
    }
    if(failure!=null) {
      throw new ApplicationConfigurationException(failure);
    }
  } finally {
    if(transaction.isActive()) {
      transaction.rollback();
    }
  }
}

private Resource initialize(final String id, final String path) {
  final Transaction transaction=
    RuntimeDelegate.
      getInstance().
        getTransactionManager().
          currentTransaction();
  transaction.begin();
  try {
    this.uow = UnitOfWork.newCurrent();
    final Resource resource=
      this.modelFactory.createResource(
        this.templateManagementService.templateOfId("personTemplate"),
        name(id));
    final Endpoint endpoint=this.modelFactory.createEndpoint(path,resource,new Date(),EntityTag.createStrong(path));
    RuntimeDelegate.getInstance().getResourceRepository().add(resource);
    RuntimeDelegate.getInstance().getEndpointRepository().add(endpoint);
    UnitOfWork.setCurrent(null);
    transaction.commit();
    return resource;
  } finally {
    if(transaction.isActive()) {
      transaction.rollback();
    }
  }
}