How to use

getCode

method

in

com.mongodb.WriteError

/**
 * Construct an instance
 * @param error the error
 * @param serverAddress the server address
 */
public MongoWriteException(final WriteError error, final ServerAddress serverAddress) {
  super(error.getCode(), error.getMessage(), serverAddress);
  this.error = error;
}

private boolean lockTransactionInMongoDB(TransactionXid transactionXid, String identifier) {
  byte[] global = transactionXid.getGlobalTransactionId();
  String instanceId = ByteUtils.byteArrayToString(global);
  try {
    String application = CommonUtils.getApplication(this.endpoint);
    String databaseName = application.replaceAll("\\W", "_");
    MongoDatabase mdb = this.mongoClient.getDatabase(databaseName);
    MongoCollection<Document> collection = mdb.getCollection(CONSTANTS_TB_LOCKS);
    Document document = new Document();
    document.append(CONSTANTS_FD_GLOBAL, instanceId);
    document.append("identifier", identifier);
    collection.insertOne(document);
    return true;
  } catch (com.mongodb.MongoWriteException error) {
    com.mongodb.WriteError writeError = error.getError();
    if (MONGODB_ERROR_DUPLICATE_KEY != writeError.getCode()) {
      logger.error("Error occurred while locking transaction(gxid= {}).", instanceId, error);
    }
    return false;
  } catch (RuntimeException rex) {
    logger.error("Error occurred while locking transaction(gxid= {}).", instanceId, rex);
    return false;
  }
}

private static boolean hasErrorCode(final WriteError error, final int expectedErrorCode) {
  return expectedErrorCode == error.getCode();
}

private static boolean hasErrorCode(final WriteError error, final int expectedErrorCode) {
  return expectedErrorCode == error.getCode();
}

/**
 * Construct an instance
 * @param error the error
 * @param serverAddress the server address
 */
public MongoWriteException(final WriteError error, final ServerAddress serverAddress) {
  super(error.getCode(), error.getMessage(), serverAddress);
  this.error = error;
}

private static void assertMongoWriteException(Callable callable, int expectedErrorCode, String expectedMessage) {
  try {
    callable.call();
    fail("MongoWriteException expected");
  } catch (MongoWriteException e) {
    assertThat(e).hasMessage(expectedMessage);
    assertThat(e.getError().getCode()).isEqualTo(expectedErrorCode);
  }
}

} catch (MongoWriteException e) {
  if (e.getError().getCode() != 11000) {
    throw e;

private void updateOrInsertTokenEntry(TrackingToken token, String processorName, int segment) {
  AbstractTokenEntry<?> tokenEntry = new GenericTokenEntry<>(token,
                                serializer,
                                contentType,
                                processorName,
                                segment);
  tokenEntry.claim(nodeId, claimTimeout);
  Bson update = combine(set("owner", nodeId),
             set("timestamp", tokenEntry.timestamp().toEpochMilli()),
             set("token", tokenEntry.getSerializedToken().getData()),
             set("tokenType", tokenEntry.getSerializedToken().getType().getName()));
  UpdateResult updateResult = mongoTemplate.trackingTokensCollection()
                       .updateOne(claimableTokenEntryFilter(processorName, segment), update);
  if (updateResult.getModifiedCount() == 0) {
    try {
      mongoTemplate.trackingTokensCollection()
             .insertOne(tokenEntryToDocument(tokenEntry));
    } catch (MongoWriteException exception) {
      if (ErrorCategory.fromErrorCode(exception.getError().getCode()) == ErrorCategory.DUPLICATE_KEY) {
        throw new UnableToClaimTokenException(format("Unable to claim token '%s[%s]'",
                               processorName,
                               segment));
      }
    }
  }
}

private void updateOrInsertTokenEntry(TrackingToken token, String processorName, int segment) {
  AbstractTokenEntry<?> tokenEntry = new GenericTokenEntry<>(token,
                                serializer,
                                contentType,
                                processorName,
                                segment);
  tokenEntry.claim(nodeId, claimTimeout);
  Bson update = combine(set("owner", nodeId),
             set("timestamp", tokenEntry.timestamp().toEpochMilli()),
             set("token", tokenEntry.getSerializedToken().getData()),
             set("tokenType", tokenEntry.getSerializedToken().getType().getName()));
  UpdateResult updateResult = mongoTemplate.trackingTokensCollection()
                       .updateOne(claimableTokenEntryFilter(processorName, segment), update);
  if (updateResult.getModifiedCount() == 0) {
    try {
      mongoTemplate.trackingTokensCollection()
             .insertOne(tokenEntryToDocument(tokenEntry));
    } catch (MongoWriteException exception) {
      if (ErrorCategory.fromErrorCode(exception.getError().getCode()) == ErrorCategory.DUPLICATE_KEY) {
        throw new UnableToClaimTokenException(format("Unable to claim token '%s[%s]'",
                               processorName,
                               segment));
      }
    }
  }
}

private AbstractTokenEntry<?> loadOrInsertTokenEntry(String processorName, int segment) {
  Document document = mongoTemplate.trackingTokensCollection()
                   .findOneAndUpdate(claimableTokenEntryFilter(processorName, segment),
                            combine(set("owner", nodeId),
                                set("timestamp", clock.millis())),
                            new FindOneAndUpdateOptions()
                                .returnDocument(ReturnDocument.AFTER));
  if (document == null) {
    try {
      AbstractTokenEntry<?> tokenEntry = new GenericTokenEntry<>(null,
                                    serializer,
                                    contentType,
                                    processorName,
                                    segment);
      tokenEntry.claim(nodeId, claimTimeout);
      mongoTemplate.trackingTokensCollection()
             .insertOne(tokenEntryToDocument(tokenEntry));
      return tokenEntry;
    } catch (MongoWriteException exception) {
      if (ErrorCategory.fromErrorCode(exception.getError().getCode()) == ErrorCategory.DUPLICATE_KEY) {
        throw new UnableToClaimTokenException(format("Unable to claim token '%s[%s]'",
                               processorName,
                               segment));
      }
    }
  }
  return documentToTokenEntry(document);
}

private AbstractTokenEntry<?> loadOrInsertTokenEntry(String processorName, int segment) {
  Document document = mongoTemplate.trackingTokensCollection()
                   .findOneAndUpdate(claimableTokenEntryFilter(processorName, segment),
                            combine(set("owner", nodeId),
                                set("timestamp", clock.millis())),
                            new FindOneAndUpdateOptions()
                                .returnDocument(ReturnDocument.AFTER));
  if (document == null) {
    try {
      AbstractTokenEntry<?> tokenEntry = new GenericTokenEntry<>(null,
                                    serializer,
                                    contentType,
                                    processorName,
                                    segment);
      tokenEntry.claim(nodeId, claimTimeout);
      mongoTemplate.trackingTokensCollection()
             .insertOne(tokenEntryToDocument(tokenEntry));
      return tokenEntry;
    } catch (MongoWriteException exception) {
      if (ErrorCategory.fromErrorCode(exception.getError().getCode()) == ErrorCategory.DUPLICATE_KEY) {
        throw new UnableToClaimTokenException(format("Unable to claim token '%s[%s]'",
                               processorName,
                               segment));
      }
    }
  }
  return documentToTokenEntry(document);
}