Examples with TypesMismatchException com.eightkdata.mongowp.exceptions.TypesMismatchException used on opensource projects

Example 1 with TypesMismatchException

use of com.eightkdata.mongowp.exceptions.TypesMismatchException in project torodb by torodb.

the class AbstractMongoOplogReader method getFirstOrLastOp.

private OplogOperation getFirstOrLastOp(boolean first) throws OplogStartMissingException, OplogOperationUnsupported, MongoException {
    Preconditions.checkState(!isClosed(), "You have to connect this client before");
    BsonDocument query = DefaultBsonValues.EMPTY_DOC;
    BsonDocument orderBy = first ? NATURAL_ORDER_SORT : INVERSE_ORDER_SORT;
    EnumSet<QueryOption> flags = EnumSet.of(QueryOption.SLAVE_OK);
    BsonDocument doc;
    MongoConnection connection = consumeConnection();
    try {
        MongoCursor<BsonDocument> cursor = connection.query(DATABASE, COLLECTION, query, 0, 1, new QueryOptions(flags), orderBy, null);
        try {
            Batch<BsonDocument> batch = cursor.fetchBatch();
            try {
                if (!batch.hasNext()) {
                    throw new OplogStartMissingException(getSyncSource());
                }
                doc = batch.next();
            } finally {
                batch.close();
            }
        } finally {
            cursor.close();
        }
        try {
            return OplogOperationParser.fromBson(doc);
        } catch (BadValueException | TypesMismatchException | NoSuchKeyException ex) {
            throw new OplogOperationUnsupported(doc, ex);
        }
    } finally {
        releaseConnection(connection);
    }
}

Example 2 with TypesMismatchException

use of com.eightkdata.mongowp.exceptions.TypesMismatchException in project torodb by torodb.

the class CollectionOptions method unmarshal.

public static CollectionOptions unmarshal(BsonDocument doc) throws BadValueException {
    boolean capped;
    try {
        capped = BsonReaderTool.getBooleanOrNumeric(doc, CAPPED_FIELD, false);
    } catch (TypesMismatchException ex) {
        capped = true;
    }
    long cappedSize;
    try {
        cappedSize = BsonReaderTool.getLong(doc, CAPPED_SIZE_FIELD, 0);
        if (cappedSize < 0) {
            throw new BadValueException("size has to be >= 0");
        }
    } catch (TypesMismatchException ex) {
        //backward compatibility
        cappedSize = 0;
    }
    long cappedMaxDocs;
    try {
        cappedMaxDocs = BsonReaderTool.getLong(doc, CAPPED_MAX_DOCS_FIELD, 0);
        if (cappedMaxDocs < 0) {
            throw new BadValueException("max has to be >= 0");
        }
    } catch (TypesMismatchException ex) {
        //backward compatibility
        cappedMaxDocs = 0;
    }
    final ImmutableList.Builder<Long> initialExtentSizes = ImmutableList.builder();
    Long initialNumExtends;
    BsonArray array;
    try {
        array = BsonReaderTool.getArray(doc, INITIAL_EXTENT_SIZES_FIELD, null);
        if (array == null) {
            initialNumExtends = null;
        } else {
            initialNumExtends = null;
            for (int i = 0; i < array.size(); i++) {
                BsonValue element = array.get(i);
                if (!element.isNumber()) {
                    throw new BadValueException("'$nExtents'.'" + i + "' has " + "the value " + element.toString() + " which is " + "not a number");
                }
                initialExtentSizes.add(element.asNumber().longValue());
            }
        }
    } catch (TypesMismatchException ex) {
        try {
            initialNumExtends = BsonReaderTool.getLong(doc, INITIAL_NUM_EXTENDS_FIELD);
        } catch (NoSuchKeyException | TypesMismatchException ex1) {
            initialNumExtends = null;
        }
    }
    AutoIndexMode autoIndexMode;
    try {
        if (BsonReaderTool.getBoolean(doc, AUTO_INDEX_MODE_FIELD)) {
            autoIndexMode = AutoIndexMode.YES;
        } else {
            autoIndexMode = AutoIndexMode.NO;
        }
    } catch (NoSuchKeyException | TypesMismatchException ex) {
        autoIndexMode = AutoIndexMode.DEFAULT;
    }
    EnumSet<Flag> flags = EnumSet.noneOf(Flag.class);
    try {
        int flagInt = BsonReaderTool.getInteger(doc, FLAGS_FIELD, 0);
        for (Flag value : Flag.values()) {
            if ((flagInt & value.bit) != 0) {
                flags.add(value);
            }
        }
    } catch (TypesMismatchException ignore) {
    //Nothing to do here
    }
    BsonDocument storageEngine;
    try {
        storageEngine = BsonReaderTool.getDocument(doc, STORAGE_ENGINE_FIELD, null);
    } catch (TypesMismatchException ex) {
        throw new BadValueException("'storageEngine' has to be a document.");
    }
    if (storageEngine != null) {
        if (storageEngine.isEmpty()) {
            throw new BadValueException("Empty 'storageEngine' options are invalid. " + "Please remove, or include valid options");
        }
        for (Entry<?> entry : storageEngine) {
            if (!entry.getValue().isDocument()) {
                throw new BadValueException("'storageEngie'.'" + entry.getKey() + "' has to be an embedded document");
            }
        }
    }
    boolean temp;
    try {
        temp = BsonReaderTool.getBoolean(doc, TEMP_FIELD, false);
    } catch (TypesMismatchException ex) {
        throw new BadValueException("Temp field must be a boolean");
    }
    return new DefaultCollectionOptions(capped, cappedSize, cappedMaxDocs, initialNumExtends, initialExtentSizes.build(), autoIndexMode, flags, storageEngine, temp);
}

Example 3 with TypesMismatchException

use of com.eightkdata.mongowp.exceptions.TypesMismatchException in project torodb by torodb.

the class OplogOperationParser method fromBson.

public static OplogOperation fromBson(@Nonnull BsonValue uncastedOp) throws BadValueException, TypesMismatchException, NoSuchKeyException {
    if (!uncastedOp.isDocument()) {
        throw new BadValueException("found a " + uncastedOp.getType().toString().toLowerCase(Locale.ROOT) + " where a document that represents a oplog operation " + "was expected");
    }
    BsonDocument doc = uncastedOp.asDocument();
    OplogOperationType opType;
    String opString = BsonReaderTool.getString(doc, "op");
    try {
        opType = OplogOperationType.fromOplogName(opString);
    } catch (IllegalArgumentException ex) {
        throw new BadValueException("Unknown oplog operation with type '" + opString + "'");
    }
    String ns;
    try {
        ns = BsonReaderTool.getString(doc, "ns");
    } catch (NoSuchKeyException ex) {
        throw new NoSuchKeyException("ns", "op does not contain required \"ns\" field: " + uncastedOp);
    } catch (TypesMismatchException ex) {
        throw ex.newWithMessage("\"ns\" field is not a string: " + uncastedOp);
    }
    if (ns.isEmpty() && !opType.equals(OplogOperationType.NOOP)) {
        throw new BadValueException("\"ns\" field value cannot be empty " + "when op type is not 'n': " + doc);
    }
    String db;
    String collection;
    int firstDotIndex = ns.indexOf('.');
    if (firstDotIndex == -1 || firstDotIndex + 1 == ns.length()) {
        db = ns;
        collection = null;
    } else {
        db = ns.substring(0, firstDotIndex);
        collection = ns.substring(firstDotIndex + 1);
    }
    OpTime optime = OpTime.fromOplogEntry(doc);
    long h = BsonReaderTool.getLong(doc, "h");
    OplogVersion version = OplogVersion.valueOf(BsonReaderTool.getInteger(doc, "v"));
    //Note: Mongodb v3 checks if the key exists or not, but doesn't check the value
    boolean fromMigrate = doc.containsKey("fromMigrate");
    BsonDocument o = BsonReaderTool.getDocument(doc, "o");
    switch(opType) {
        case DB:
            return new DbOplogOperation(db, optime, h, version, fromMigrate);
        case DB_CMD:
            return new DbCmdOplogOperation(o, db, optime, h, version, fromMigrate);
        case DELETE:
            return new DeleteOplogOperation(o, db, collection, optime, h, version, fromMigrate, BsonReaderTool.getBoolean(doc, "b", false));
        case INSERT:
            //TODO: parse b
            return new InsertOplogOperation(o, db, collection, optime, h, version, fromMigrate);
        case NOOP:
            return new NoopOplogOperation(o, db, optime, h, version, fromMigrate);
        case UPDATE:
            return new UpdateOplogOperation(BsonReaderTool.getDocument(doc, "o2"), db, collection, optime, h, version, fromMigrate, o, BsonReaderTool.getBoolean(doc, "b", false));
        default:
            throw new AssertionError(OplogOperationParser.class + " is not prepared to work with oplog operations of type " + opType);
    }
}

Example 4 with TypesMismatchException

use of com.eightkdata.mongowp.exceptions.TypesMismatchException in project torodb by torodb.

the class ReplicaSetConfig method fromDocument.

public static ReplicaSetConfig fromDocument(@Nonnull BsonDocument bson) throws BadValueException, TypesMismatchException, NoSuchKeyException, FailedToParseException {
    BsonReaderTool.checkOnlyHasFields("replica set configuration", bson, VALID_FIELD_NAMES);
    String id = BsonReaderTool.getString(bson, ID_FIELD);
    int version = BsonReaderTool.getInteger(bson, VERSION_FIELD);
    Builder builder = new Builder(id, version);
    BsonArray uncastedMembers = BsonReaderTool.getArray(bson, MEMBERS_FIELD);
    int i = 0;
    for (BsonValue uncastedMember : uncastedMembers) {
        if (uncastedMember == null || !uncastedMember.isDocument()) {
            throw new TypesMismatchException(Integer.toString(i), "object", uncastedMember == null ? null : uncastedMember.getType());
        }
        builder.addMemberConfig(MemberConfig.fromDocument(uncastedMember.asDocument()));
        i++;
    }
    BsonDocument settings;
    try {
        settings = BsonReaderTool.getDocument(bson, SETTINGS_FIELD);
    } catch (NoSuchKeyException ex) {
        settings = DefaultBsonValues.EMPTY_DOC;
    }
    builder.setHbTimeout(BsonReaderTool.getInteger(settings, HEARTHBEAT_TIMEOUT_FIELD, DEFAULT_HEARTBEAT_TIMEOUT_MILLIS)).setChainingAllowed(BsonReaderTool.getBoolean(settings, CHAINING_ALLOWED_FIELD, DEFAULT_CHAINING_ALLOWED));
    BsonDocument uncastedGetLastErrorDefaults = BsonReaderTool.getDocument(settings, GET_LAST_ERROR_DEFAULTS_FIELD);
    WriteConcern wc = WriteConcern.fromDocument(uncastedGetLastErrorDefaults);
    builder.setWriteConcern(wc);
    BsonDocument uncastedCustomWriteConcerns;
    try {
        uncastedCustomWriteConcerns = BsonReaderTool.getDocument(settings, GET_LAST_ERROR_MODES_FIELD);
    } catch (NoSuchKeyException ex) {
        uncastedCustomWriteConcerns = DefaultBsonValues.EMPTY_DOC;
    }
    Map<String, ReplicaSetTagPattern> customWriteConcernsBuilder = parseCustomWriteConcerns(uncastedCustomWriteConcerns);
    for (Map.Entry<String, ReplicaSetTagPattern> customWriteConcern : customWriteConcernsBuilder.entrySet()) {
        builder.putCustomWriteConcern(customWriteConcern.getKey(), customWriteConcern.getValue());
    }
    builder.setProtocolVersion(BsonReaderTool.getLong(bson, PROTOCOL_VERSION_FIELD));
    return builder.build();
}

Example 5 with TypesMismatchException

use of com.eightkdata.mongowp.exceptions.TypesMismatchException in project torodb by torodb.

the class MemberConfig method fromDocument.

public static MemberConfig fromDocument(BsonDocument bson) throws TypesMismatchException, NoSuchKeyException, BadValueException {
    int id = BsonReaderTool.getNumeric(bson, "_id").intValue();
    HostAndPort host = BsonReaderTool.getHostAndPort(bson, "host");
    Builder builder = new Builder(id, host).setVotes(BsonReaderTool.getInteger(bson, "votes", DEFAULT_VOTES)).setPriority(BsonReaderTool.getDouble(bson, "priority", DEFAULT_PRIORITY)).setArbiterOnly(BsonReaderTool.getBooleanOrNumeric(bson, "arbiterOnly", DEFAULT_ARBITER_ONLY)).setSlaveDelay(BsonReaderTool.getNumeric(bson, "slaveDelay", DEFAULT_SLAVE_DELAY).longValue()).setHidden(BsonReaderTool.getBooleanOrNumeric(bson, "hidden", DEFAULT_HIDDEN)).setBuildIndexes(BsonReaderTool.getBooleanOrNumeric(bson, "buildIndexes", DEFAULT_BUILD_INDEXES));
    BsonDocument castedTags = BsonReaderTool.getDocument(bson, "tags");
    for (Entry entry : castedTags) {
        BsonValue value = entry.getValue();
        if (value.isString()) {
            throw new TypesMismatchException(entry.getKey(), "string", value.getType());
        }
        String castedValue = value.asString().getValue();
        builder.putTag(entry.getKey(), castedValue);
    }
    return builder.build();
}