How to use

TransactionIsolation

in

com.bagri.core.api

public void setTransactionLevel(String txLevel) throws BagriException {
  logger.debug("setTransactionLevel.enter; got tx level: {}", txLevel);
  if (txLevel == null || txLevel.isEmpty() || txLevel.equals(pv_client_txLevel_skip)) {
    this.txLevel = null;
  } else {
    this.txLevel = TransactionIsolation.valueOf(txLevel);
  }
  logger.debug("setTransactionLevel.exit; default tx level set to: {}", this.txLevel);
}
 

  @Override
  public void writeData(ObjectDataOutput out) throws IOException {
    super.writeData(out);
    out.writeUTF(txIsolation.name());
  }
}

/**
 * {@inheritDoc} 
 */
public Map<String, Object> convert() {
  Map<String, Object> result = new HashMap<>();
  result.put("txId", txId);
  result.put("started at", new Date(startedAt).toString());
  result.put("started by", startedBy);
  long finished;
  if (finishedAt > 0) {
    finished = finishedAt;
  } else {
    finished = System.currentTimeMillis();
  }
  result.put("duration", DateUtils.getDuration(finished - startedAt));
  result.put("isolation", txIsolation.toString());
  result.put("state", txState.toString());
  result.put("docs created", docsCreated);
  result.put("docs updated", docsUpdated);
  result.put("docs deleted", docsDeleted);
  return result;
}

} else if (!lastKey.equals(entry.getKey())) { 
  if (lastKey.getRevision() <= entry.getKey().getRevision()) {
    if (txStart > TX_NO && tx.getTxIsolation().ordinal() > TransactionIsolation.readCommited.ordinal()) {
      return new BagriException("Document with key: " + entry.getKey() +	", uri: " + uri +
          " has been concurrently inserted; latest key is: " + lastKey, BagriException.ecDocument);
if (lastKey != null && !lastKey.equals(entry.getKey())) {
  if (lastKey.getVersion() > entry.getKey().getVersion()) {
    if (txStart > TX_NO && tx.getTxIsolation().ordinal() > TransactionIsolation.readCommited.ordinal()) {
      return new BagriException("Document with key: " + entry.getKey() +	", uri: " + uri +
          " has been concurrently updated; latest key is: " + lastKey, BagriException.ecDocument);

private Transaction readTx() {
  TransactionState state = TransactionState.values()[buff.get()];
  long id = buff.getLong();
  long start = buff.getLong();
  long finish = buff.getLong();
  TransactionIsolation isol = TransactionIsolation.values()[buff.get()];
  byte[] by26 = new byte[byLen];
  buff.get(by26);
  int sz = 0;
  while (sz < byLen && by26[sz] > 0) {
    sz++;
  }
  String owner = new String(by26, 0, sz);
  Transaction xtx = new Transaction(id, start, finish, owner, isol, state);
  xtx.updateCounters(buff.getInt(), buff.getInt(), buff.getInt());
  return xtx;
}

@Override
public Object process(Map.Entry<DocumentKey, Document> entry) {
  doc = entry.getValue();
  long txStart = tx == null ? TX_NO : tx.getTxId();
  DocumentKey lastKey = ddSvc.getLastKeyForUri(doc.getUri());
  if (lastKey == null) {
    return new BagriException("Document with key: " + entry.getKey() + ", uri: " + doc.getUri() +
        " has been concurrently removed", BagriException.ecDocument);
  } else if (lastKey.getVersion() > entry.getKey().getVersion()) {
    if (txStart > TX_NO && tx.getTxIsolation().ordinal() > TransactionIsolation.readCommited.ordinal()) {
      return new BagriException("Document with key: " + entry.getKey() + ", uri: " + doc.getUri() +
          " has been concurrently updated; latest key is: " + lastKey, BagriException.ecDocument);
    }
    doc = docMgr.getDocument(lastKey);
  }
  try {
    return docMgr.processDocumentRemoval(entry, properties, txStart, doc);
  } catch (BagriException ex) {
    return ex;
  }
}

@Override
public Transaction read(ObjectDataInput in) throws IOException {
  
  ContentDataPool cdPool = ContentDataPool.getDataPool();
  Transaction xTrans = new Transaction(in.readLong(),
      in.readLong(),
      in.readLong(),
      cdPool.intern(in.readUTF()),
      TransactionIsolation.values()[in.readInt()],
      TransactionState.values()[in.readInt()]);
  xTrans.updateCounters(in.readInt(), in.readInt(), in.readInt());
  return xTrans;
}

@POST
@Produces(MediaType.TEXT_PLAIN) 
@ApiOperation(value = "postTx: starts a new user Transaction in the current session")
public Response postTx(String isolation) {
  TransactionManagement txMgr = getTxManager();
  try {
    long txId = txMgr.beginTransaction(TransactionIsolation.valueOf(isolation));
    return Response.created(UriBuilder.fromPath("/tx/" + txId).build()).entity(txId).build();
  } catch (Exception ex) {
    logger.error("postTx.error", ex);
    throw new WebApplicationException(ex, Status.INTERNAL_SERVER_ERROR);
  }
}

private void writeTx(Transaction xtx) {
  buff.put((byte) xtx.getTxState().ordinal());
  buff.putLong(xtx.getTxId());
  buff.putLong(xtx.getStartedAt());
  buff.putLong(xtx.getFinishedAt());
  buff.put((byte) xtx.getTxIsolation().ordinal());
  buff.putInt(xtx.getDocsCreated());
  buff.putInt(xtx.getDocsUpdated());
  buff.putInt(xtx.getDocsDeleted());
  byte[] by = xtx.getStartedBy().getBytes();
  byte[] by26 = new byte[byLen];
  for (int i=0; i < by.length; i++) {
    by26[i] = by[i];
  }
  buff.put(by26);
  //buff.force();
}

public TransactionIsolation getTransactionLevel(Properties context) { 
  String txLevel = context.getProperty(pn_client_txLevel);
  if (txLevel == null) {
    return ((TransactionManagementImpl) getTxManagement()).getTransactionLevel(); 
  } else {
    if (pv_client_txLevel_skip.equals(txLevel)) {
      return null;
    }
    return TransactionIsolation.valueOf(txLevel);
  }
}
     

@Override
public void write(ObjectDataOutput out, Transaction xTrans) throws IOException {
  
  out.writeLong(xTrans.getTxId());
  out.writeLong(xTrans.getStartedAt());
  out.writeLong(xTrans.getFinishedAt());
  out.writeUTF(xTrans.getStartedBy());
  out.writeInt(xTrans.getTxIsolation().ordinal());
  out.writeInt(xTrans.getTxState().ordinal());
  out.writeInt(xTrans.getDocsCreated());
  out.writeInt(xTrans.getDocsUpdated());
  out.writeInt(xTrans.getDocsDeleted());
}

@Override
public void readData(ObjectDataInput in) throws IOException {
  super.readData(in);
  txIsolation = TransactionIsolation.valueOf(in.readUTF());
}

@ManagedOperation(description="Starts new transaction")
@ManagedOperationParameters({
  @ManagedOperationParameter(name = "txIsolation", description = "Tx isolation level")})
public long beginTransaction(String txIsolation) {
  try {
    if (txIsolation == null || txIsolation.length() == 0) {
      return txMgr.beginTransaction();
    } 
    return txMgr.beginTransaction(TransactionIsolation.valueOf(txIsolation));
  } catch (BagriException ex) {
    logger.error("beginTransaction.error: " + ex.getMessage(), ex);
  }
  return 0;
}

  @Override
  public Sequence call(XPathContext context, Sequence[] arguments) throws XPathException {
    long txId;
    try {
      if (arguments.length > 0) {
        txId = txMgr.beginTransaction(TransactionIsolation.valueOf(arguments[0].head().getStringValue()));
      } else {
        txId = txMgr.beginTransaction(); 
      }
      return new Int64Value(txId);
    } catch (BagriException ex) {
      throw new XPathException(ex);
    }
  }
};